diff --git a/.github/menudet-native-ref b/.github/menudet-native-ref new file mode 100644 index 000000000..042a8689b --- /dev/null +++ b/.github/menudet-native-ref @@ -0,0 +1 @@ +e77b91aca382a6123ca04f4e2dbc2430f147e2d6 diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index a0c8a19e8..ece60cb92 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -15,6 +15,7 @@ jobs: env: CMAKE_GENERATOR: Ninja strategy: + fail-fast: false matrix: os: [ubuntu-latest, windows-latest, macos-latest] python-version: ["3.12"] @@ -33,6 +34,31 @@ jobs: steps: - uses: actions/checkout@v7 + # Experimental tests require the explicit native pair, not the unchanged + # release dependency. Keep this source override local to numpy-compat CI. + - name: Select experimental native revision + if: github.ref == 'refs/heads/numpy-compat' || github.ref == 'refs/heads/portable-jit-improvements' + id: native_ref + shell: bash + run: echo "sha=$(cat .github/menudet-native-ref)" >> "$GITHUB_OUTPUT" + + - uses: actions/checkout@v7 + if: github.ref == 'refs/heads/numpy-compat' || github.ref == 'refs/heads/portable-jit-improvements' + with: + repository: Blosc/miniexpr + ref: ${{ steps.native_ref.outputs.sha }} + path: ci-native + + - name: Override experimental native source + if: github.ref == 'refs/heads/numpy-compat' || github.ref == 'refs/heads/portable-jit-improvements' + shell: bash + run: | + source_path="$PWD/ci-native" + if [ "$RUNNER_OS" = Windows ]; then + source_path=$(cygpath -m "$source_path") + fi + echo "CMAKE_ARGS=-DFETCHCONTENT_SOURCE_DIR_MINIEXPR=$source_path" >> "$GITHUB_ENV" + - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v7 with: @@ -67,17 +93,18 @@ jobs: if: runner.os == 'Windows' run: echo "C:\\Program Files\\LLVM\\bin" >> $env:GITHUB_PATH - - name: Install specific numpy version - if: matrix.numpy-version - run: pip install "numpy==${{ matrix.numpy-version }}.*" + - name: Resolve compiler cache launcher (Windows) + if: runner.os == 'Windows' + run: | + $launcher = (Get-Command sccache -CommandType Application -ErrorAction Stop).Source.Replace('\', '/') + "CMAKE_C_COMPILER_LAUNCHER=$launcher" >> $env:GITHUB_ENV + "CMAKE_CXX_COMPILER_LAUNCHER=$launcher" >> $env:GITHUB_ENV - name: Build (Windows) if: runner.os == 'Windows' id: build_windows run: pip install -e . --group test env: - CMAKE_C_COMPILER_LAUNCHER: sccache - CMAKE_CXX_COMPILER_LAUNCHER: sccache SCCACHE_DIR: C:\Users\runneradmin\AppData\Local\sccache CC: clang-cl CXX: clang-cl @@ -89,9 +116,31 @@ jobs: id: build_non_windows run: pip install -e . --group test + - name: Install Arrow dictionary test dependency + # Pandas is already a dev dependency; Arrow's dictionary conversions now + # import it even when the test does not construct a pandas object. + run: python -m pip install pandas + + # Build isolation uses NumPy 2 headers for the dual-ABI extension. Optional + # test dependencies may upgrade the runtime too, so pin it AFTER installing. + - name: Install NumPy 1.26-compatible test runtime + if: matrix.numpy-version == '1.26' + # PyArrow 26 dropped the NumPy 1 ABI without encoding it in Requires-Dist. + # Keep this host-compatibility job on a known dual-ABI Arrow release. + run: pip install "numpy==1.26.*" "zarr>=3.1.5,<3.2" "pyarrow==21.0.0" pandas + + - name: Verify requested NumPy runtime + if: matrix.numpy-version + run: python -c "import numpy as np; assert np.__version__.startswith('${{ matrix.numpy-version }}.'), np.__version__" + + - name: Require a NumExpr-free runtime + run: | + python -m pip uninstall -y numexpr + python -c "import importlib.util, importlib.metadata; assert importlib.util.find_spec('numexpr') is None; assert not any(r.lower().startswith('numexpr') for r in importlib.metadata.requires('blosc2') or [])" + - name: Test (Windows) if: runner.os == 'Windows' - run: python -m pytest -m "not heavy and not network and not tui" --durations=25 + run: python scripts/qualify_without_numexpr.py --require-absent -- -m "not heavy and not network and not tui" --durations=25 env: # A test over this many seconds is a deadlock, not a slow test (the # slowest is ~7 s): dump stacks and kill the worker so xdist names it @@ -101,16 +150,44 @@ jobs: PYTEST_DEADMAN_SECONDS: "300" PYTEST_DEADMAN_SESSION_SECONDS: "1500" # BLOSC_NTHREADS: "1" -# NUMEXPR_NUM_THREADS: "1" # OMP_NUM_THREADS: "1" - name: Test (non-Windows) if: runner.os != 'Windows' - run: python -m pytest -m "not heavy and not network and not tui" --durations=25 + run: python scripts/qualify_without_numexpr.py --require-absent -- -m "not heavy and not network and not tui" --durations=25 env: PYTEST_DEADMAN_SECONDS: "300" PYTEST_DEADMAN_SESSION_SECONDS: "1500" + - name: Verify independence with optional NumExpr installed + if: runner.os == 'Linux' && matrix.python-version == '3.12' && !matrix.numpy-version + run: | + python -m pip install numexpr + python -m pytest tests/test_no_numexpr.py -q -n 0 + + - name: Verify experimental safe-graph corpus + if: always() && (steps.build_windows.outcome == 'success' || steps.build_non_windows.outcome == 'success') + run: python scripts/verify_safe_lazyexpr.py --report safe-lazyexpr.json + + - name: Upload safe-graph platform evidence + if: always() + uses: actions/upload-artifact@v4 + with: + name: safe-lazyexpr-${{ matrix.os }}-py${{ matrix.python-version }}-np${{ matrix.numpy-version || 'default' }} + path: safe-lazyexpr.json + if-no-files-found: ignore + + - name: Certify bounded Menudet math against independent references + run: python scripts/certify_menudet_math.py --report menudet-math.json + + - name: Upload Menudet math certification + if: always() + uses: actions/upload-artifact@v4 + with: + name: menudet-math-${{ matrix.os }}-py${{ matrix.python-version }}-np${{ matrix.numpy-version || 'default' }} + path: menudet-math.json + if-no-files-found: ignore + # TUIs are timing-sensitive and only boot a headless terminal: one OS is # enough, and a flake here is feedback, not a release blocker. - name: Test TUI (non-blocking) diff --git a/.github/workflows/cibuildwheels.yml b/.github/workflows/cibuildwheels.yml index c043f7aab..5f4e759fd 100644 --- a/.github/workflows/cibuildwheels.yml +++ b/.github/workflows/cibuildwheels.yml @@ -1,6 +1,8 @@ name: Python wheels on: + # Certify development revisions without creating a release tag or publishing. + workflow_dispatch: # Trigger the workflow only for tags and PRs to the main branch push: tags: @@ -11,6 +13,22 @@ on: env: CIBW_BUILD_VERBOSITY: 1 + # Every tested wheel checks portable descriptors/persistence and independent + # numeric references, not only whether the extension can be imported. + # Free-threaded CPython safely enables the GIL for this extension. Allow only + # that expected import warning; never force PYTHON_GIL=0 or claim no-GIL safety. + CIBW_TEST_COMMAND: >- + python -m pytest + {project}/tests/test_portable_artifact.py + {project}/tests/test_portable_descriptor.py + {project}/tests/test_portable_descriptor_host.py + {project}/tests/test_portable_lazy.py + {project}/tests/test_portable_jit_integration.py + {project}/tests/test_portable_policy.py + {project}/tests/test_portable_table_export.py + {project}/tests/test_dsl_portable.py -q -n 0 && + python {project}/scripts/certify_menudet_math.py && + python {project}/scripts/verify_safe_lazyexpr.py # Skip testing on aarch64 for now, as it is emulated on GitHub Actions and takes too long # Now that github provides native arm64 runners, we can enable tests again # CIBW_TEST_SKIP: "*linux*aarch64*" @@ -156,7 +174,10 @@ jobs: CIBW_BUILD: ${{ matrix.cibw_build }} # WASM/Pyodide has no SIMD/runtime CPU detection; disable optimised paths CMAKE_ARGS: "-DWITH_ZLIB_OPTIM=OFF -DWITH_OPTIM=OFF -DWITH_RUNTIME_CPU_DETECTION=OFF" - CIBW_TEST_COMMAND: "pytest {project}/tests" + CIBW_TEST_COMMAND: >- + pytest {project}/tests && + python {project}/scripts/certify_menudet_math.py && + python {project}/scripts/verify_safe_lazyexpr.py # Pin the Pyodide version explicitly per target for reproducible builds. # Note: in-memory SChunk get_slice is broken on the Pyodide 0.29.x # Emscripten toolchain (works on 314); see gh-664. The affected test is @@ -282,6 +303,9 @@ jobs: python -m pytest tests/test_open.py tests/test_vlmeta.py \ tests/ndarray/test_evaluate.py -q -p no:cacheprovider + - name: Certify Menudet on the installed abi3 wheel + run: python scripts/certify_menudet_math.py + upload_pypi: needs: [ build_wheels, build_wheels_wasm, test_abi3_matrix ] diff --git a/.github/workflows/menudet-paired.yml b/.github/workflows/menudet-paired.yml new file mode 100644 index 000000000..516a63b7e --- /dev/null +++ b/.github/workflows/menudet-paired.yml @@ -0,0 +1,116 @@ +name: Menudet paired qualification + +# Keep release dependency pins unchanged. Qualification explicitly selects the +# experimental native revision and fails rather than hiding missing capabilities. +on: + push: + branches: [numpy-compat] + workflow_dispatch: + inputs: + native_ref: + description: Fully qualified exact Blosc/miniexpr SHA to integrate with this Python revision + required: true + type: string + +concurrency: + group: menudet-pair-${{ github.ref }}-${{ inputs.native_ref }} + cancel-in-progress: true + +jobs: + paired: + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest, windows-latest] + runs-on: ${{ matrix.os }} + defaults: + run: + shell: bash -el {0} + env: + MENUDET_REQUIRE_ARRAY_RUNTIME: '1' + MENUDET_REQUIRE_GRAPH_RUNTIME: '1' + CMAKE_GENERATOR: Ninja + steps: + - uses: actions/checkout@v7 + - uses: conda-incubator/setup-miniconda@v3 + with: + activate-environment: blosc2 + python-version: '3.12' + auto-activate-base: false + - name: Require exact full native qualification + id: qualified_native + env: + GH_TOKEN: ${{ github.token }} + REQUESTED_NATIVE: ${{ inputs.native_ref }} + run: | + native_sha="$REQUESTED_NATIVE" + if [ -z "$native_sha" ]; then native_sha=$(cat .github/menudet-native-ref); fi + python scripts/verify_native_qualification.py "$native_sha" + echo "sha=$native_sha" >> "$GITHUB_OUTPUT" + - uses: actions/checkout@v7 + with: + repository: Blosc/miniexpr + ref: ${{ steps.qualified_native.outputs.sha }} + path: native + - uses: ilammy/msvc-dev-cmd@v1 + if: runner.os == 'Windows' + - name: Select Windows compiler + if: runner.os == 'Windows' + run: | + echo 'CC=clang-cl' >> "$GITHUB_ENV" + echo 'CXX=clang-cl' >> "$GITHUB_ENV" + - name: Build explicit native and Python pair + run: | + python -m pip install ninja cmake + # Match Python's static linkage; Windows Ninja cannot emit both the + # shared import library and static library as miniexpr.lib. + cmake -S native -B native-build -DMINIEXPR_BUILD_ARTIFACT=ON -DMINIEXPR_BUILD_SHARED=OFF -DCMAKE_BUILD_TYPE=Release + # Python's corpus adapter needs this runner, not the native test matrix. + cmake --build native-build --target numpy_compat_runner --parallel 4 + native_source="$PWD/native" + if [ "$RUNNER_OS" = Windows ]; then + native_source=$(cygpath -m "$native_source") + fi + python -m pip install -e . --group test --config-settings="cmake.define.FETCHCONTENT_SOURCE_DIR_MINIEXPR=$native_source" + python -m pip install 'numpy==2.5.3' + - name: Require corpus and native array capabilities + run: | + export MENUDET_NUMPY_FUNCTION_CORPUS="$PWD/native/tests/numpy-compat/functions-v1.0.json" + export MENUDET_NUMPY_ARITHMETIC_CORPUS="$PWD/native/tests/numpy-compat/arithmetic-v1.0.json" + export MENUDET_NUMPY_CORPUS="$PWD/native/tests/numpy-compat/vectors.json" + export MENUDET_NUMPY_CORPUS_V2="$PWD/native/tests/numpy-compat/vectors-v2.json" + export MENUDET_NUMPY_RUNNER="$PWD/native-build/tests/numpy_compat_runner" + if [ "$RUNNER_OS" = Windows ]; then + export MENUDET_NUMPY_RUNNER="${MENUDET_NUMPY_RUNNER}.exe" + export PATH="$PWD/native-build:$PATH" + fi + python -c 'import blosc2; assert blosc2.NativeGraph.from_expression("x - sum(x)", {"x": "float32"}).info()["stages"] == 2' + python -m pytest tests/test_menudet_arrays.py tests/test_menudet_native_graph.py tests/test_native_graph_preparation.py tests/test_native_graph_stages.py tests/test_menudet_functions.py tests/test_menudet_arithmetic.py tests/test_menudet_conformance.py tests/test_dsl_portable.py tests/test_portable_artifact.py tests/test_portable_lazy.py tests/test_portable_table_export.py tests/test_portable_policy.py tests/test_portable_descriptor.py tests/test_native_graph_weak_captures.py tests/test_dsl_scalar_dispatch.py -q -n 0 + - name: Build exact-pair distribution wheel + env: + ME_DSL_JIT_COMPILER: tcc + MENUDET_REQUIRE_JIT: ${{ runner.os != 'Windows' && '1' || '0' }} + run: | + native_source="$PWD/native" + if [ "$RUNNER_OS" = Windows ]; then + native_source=$(cygpath -m "$native_source") + fi + python -m pip wheel . --no-deps --wheel-dir graph-wheels --config-settings="cmake.define.FETCHCONTENT_SOURCE_DIR_MINIEXPR=$native_source" + python -m pip install --force-reinstall --no-deps graph-wheels/*.whl + python -m pytest tests/test_portable_jit_integration.py tests/test_menudet_jit.py -q -n 0 + - name: Record exact paired revisions + if: always() + run: | + git rev-parse HEAD > paired-revisions.txt + git -C native rev-parse HEAD >> paired-revisions.txt + python --version >> paired-revisions.txt + python -m pip freeze >> paired-revisions.txt + cmake --version >> paired-revisions.txt + - uses: actions/upload-artifact@v4 + if: always() + with: + name: menudet-pair-${{ matrix.os }} + path: | + paired-revisions.txt + native-qualification.json + graph-wheels/*.whl diff --git a/.github/workflows/wasm-tests.yml b/.github/workflows/wasm-tests.yml index c9ef42595..f771c2ae8 100644 --- a/.github/workflows/wasm-tests.yml +++ b/.github/workflows/wasm-tests.yml @@ -19,9 +19,27 @@ jobs: # WASM/Pyodide has no SIMD/runtime CPU detection; disable optimised paths CMAKE_ARGS: "-DWITH_ZLIB_OPTIM=OFF -DWITH_OPTIM=OFF -DWITH_RUNTIME_CPU_DETECTION=OFF" # cibuildwheel runs the suite automatically in the node/pyodide runtime - CIBW_TEST_COMMAND: "pytest {project}/tests" + CIBW_TEST_COMMAND: >- + pytest {project}/tests && + python {project}/scripts/certify_menudet_math.py && + python {project}/scripts/verify_safe_lazyexpr.py steps: - uses: actions/checkout@v7 + # Qualify the experimental pair without changing the shipping native pin. + - name: Select experimental native revision + if: github.ref == 'refs/heads/numpy-compat' || github.ref == 'refs/heads/portable-jit-improvements' + id: native_ref + run: echo "sha=$(cat .github/menudet-native-ref)" >> "$GITHUB_OUTPUT" + - uses: actions/checkout@v7 + if: github.ref == 'refs/heads/numpy-compat' || github.ref == 'refs/heads/portable-jit-improvements' + with: + repository: Blosc/miniexpr + ref: ${{ steps.native_ref.outputs.sha }} + path: ci-native + - name: Override experimental native source + if: github.ref == 'refs/heads/numpy-compat' || github.ref == 'refs/heads/portable-jit-improvements' + run: | + echo "CMAKE_ARGS=$CMAKE_ARGS -DFETCHCONTENT_SOURCE_DIR_MINIEXPR=$PWD/ci-native" >> "$GITHUB_ENV" - uses: actions/setup-python@v7 with: python-version: '3.x' @@ -30,4 +48,31 @@ jobs: - name: Install cibuildwheel run: pip install "cibuildwheel==4.1.*" - name: Build and test wheel - run: cibuildwheel --platform pyodide # platform=pyodide is CLI-only + run: | + set -o pipefail + cibuildwheel --platform pyodide 2>&1 | tee wasm-ci.log + - name: Extract safe-graph runtime evidence + if: always() + run: | + python - <<'PY' + import json + from pathlib import Path + + log = Path("wasm-ci.log") + if log.exists(): + text = log.read_text() + marker = '{\n "scope": "bounded experimental safe-graph corpus;' + start = text.rfind(marker) + if start >= 0: + report, _ = json.JSONDecoder().raw_decode(text[start:]) + Path("safe-lazyexpr-wasm.json").write_text(json.dumps(report, indent=2) + "\n") + PY + - name: Upload WASM platform evidence + if: always() + uses: actions/upload-artifact@v4 + with: + name: safe-lazyexpr-wasm + path: | + safe-lazyexpr-wasm.json + wasm-ci.log + if-no-files-found: ignore diff --git a/AGENTS.md b/AGENTS.md index 78094dd41..8eede1888 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -25,6 +25,23 @@ shared library and fail with errors like - `pytest -m "network"` runs tests requiring network access. - `cd doc && rm -rf ../html _build && python -m sphinx . ../html` builds docs. +### Fast Native/Python Iteration +- Keep a persistent CMake build directory and reuse the same native source + override (`FETCHCONTENT_SOURCE_DIR_MINIEXPR`) when testing a local miniexpr checkout. +- After native/Cython edits, prefer a direct incremental build over rebuilding a + wheel or repeating `pip install -e .`: + `conda run -n blosc2 cmake --build --parallel 8`. +- Verify `blosc2.__file__` and `blosc2.blosc2_ext.__file__` before testing: both must + belong to the intended checkout/test package. A direct build does not necessarily + update the extension copy loaded by an editable install. If needed, refresh only + the rebuilt extensions in an isolated test package; do not overwrite another + checkout's shared installation. +- For isolated imports, use conda Python with `-S` and explicitly select the test + package and dependency paths. Run pytest in that process with `-n 0`; workers can + otherwise reload the shared editable install instead of the intended package. +- Pure Python edits need no rebuild. Reinstall when packaging/configuration changes + require it, and retain independent-wheel checks for final integration qualification. + ## Coding Style & Naming Conventions Use Ruff for formatting and linting (line length 109). Enable pre-commit hooks: `python -m pip install pre-commit` then `pre-commit install`. Follow Python @@ -48,7 +65,21 @@ adds `--doctest-modules`, so keep doctest examples in `blosc2/core.py`, `blosc2/ndarray.py`, and `blosc2/schunk.py` accurate. Use markers `heavy` and `network` for slow or network-dependent tests. +Test behavior at the layer that owns it: exhaustive native numerical semantics, +dtype/operator matrices, and JIT backend parity belong in miniexpr (or C-Blosc2 +for its features). Python-Blosc2 tests should focus on bindings, API contracts, +dispatch, scheduling, and a small representative set of end-to-end cases. Check +existing native coverage before adding parametrized Python matrices; extend the +native tests rather than duplicating their cross-products here. + ## Commit & Pull Request Guidelines +### GitHub CI Monitoring +- Use `gh run watch --interval 60 --exit-status` (or a longer interval), + never the three-second default. Avoid duplicate watchers across agents. +- On rate limits, stop requests until `Retry-After` or `X-RateLimit-Reset` allows + resuming. Watcher/API errors do not imply CI test failures. + +### Commits and Pull Requests Recent commit messages are short, imperative sentences (e.g., “Add …”, “Fix …”) without ticket prefixes. For pull requests: branch from `main`, add tests for behavior changes, update docs for API changes, ensure the test suite passes, diff --git a/CMakeLists.txt b/CMakeLists.txt index e9c5a078b..a124297b4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -16,8 +16,8 @@ project(python-blosc2) # Update to the latest minimum C-Blosc2 version, and to the actual bundled one set(BLOSC2_MIN_VERSION 3.3.0) -set(BLOSC2_BUNDLED_VERSION v3.3.5) -#set(BLOSC2_BUNDLED_VERSION a54e259aeb1c0e62d6bbea28934369d4831e4046) +#set(BLOSC2_BUNDLED_VERSION v3.3.5) +set(BLOSC2_BUNDLED_VERSION 6c65c5ae3d56e520966ef38c048efd9a8f4fe748) if(WIN32 AND NOT CMAKE_C_COMPILER_ID STREQUAL "Clang") message(FATAL_ERROR "Windows builds require clang-cl. Set CC/CXX to clang-cl or configure CMake with -T ClangCL.") @@ -65,6 +65,8 @@ add_custom_command( COMMAND Python::Interpreter -m cython "${CMAKE_CURRENT_SOURCE_DIR}/src/blosc2/blosc2_ext.pyx" --output-file blosc2_ext.c DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/blosc2/blosc2_ext.pyx" + "${CMAKE_CURRENT_SOURCE_DIR}/src/blosc2/dsl_artifact_bridge.h" + "${CMAKE_CURRENT_SOURCE_DIR}/src/blosc2/dsl_graph_bridge.h" VERBATIM) add_custom_command( @@ -117,6 +119,7 @@ set(MINIEXPR_BUILD_SHARED OFF CACHE BOOL "Build miniexpr shared library" FORCE) set(MINIEXPR_BUILD_TESTS OFF CACHE BOOL "Build miniexpr tests" FORCE) set(MINIEXPR_BUILD_EXAMPLES OFF CACHE BOOL "Build miniexpr examples" FORCE) set(MINIEXPR_BUILD_BENCH OFF CACHE BOOL "Build miniexpr benchmarks" FORCE) +option(MINIEXPR_BUILD_ARTIFACT "Build portable DSL artifact support" ON) # Keep miniexpr's and C-Blosc2's bundled files inside the blosc2 package. # Without this, their install rules use the default CMAKE_INSTALL_LIBDIR # ("lib"), which scikit-build places at site-packages/lib. @@ -140,13 +143,33 @@ endif() FetchContent_Declare(miniexpr GIT_REPOSITORY https://github.com/Blosc/miniexpr.git - GIT_TAG 3f4db93a628aedc662b7d27a5f35c97ffaeb0424 + GIT_TAG b6786bec8fabb9a295f6f3b3050d267ee697092d # SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../miniexpr ) FetchContent_MakeAvailable(miniexpr) # Link against miniexpr static library target_link_libraries(blosc2_ext PRIVATE miniexpr_static) +if(TARGET miniexpr_artifact) + target_link_libraries(blosc2_ext PRIVATE miniexpr_artifact) + target_compile_definitions(blosc2_ext PRIVATE B2_HAVE_PORTABLE_ARTIFACT=1) + file(STRINGS "${miniexpr_SOURCE_DIR}/src/miniexpr_artifact.h" B2_ARRAY_SOURCE_DECLARATION + REGEX "^me_artifact_status me_artifact_eval_array_sources\\(") + if(B2_ARRAY_SOURCE_DECLARATION) + target_compile_definitions(blosc2_ext PRIVATE B2_HAVE_ARRAY_SOURCES=1) + endif() + if(EXISTS "${miniexpr_SOURCE_DIR}/src/miniexpr_graph.h") + target_compile_definitions(blosc2_ext PRIVATE B2_HAVE_NATIVE_GRAPH=1) + file(STRINGS "${miniexpr_SOURCE_DIR}/src/miniexpr_graph.h" B2_GRAPH_SOURCE_DECLARATION + REGEX "^me_graph_status me_graph_execute_sources\\(") + if(B2_GRAPH_SOURCE_DECLARATION AND B2_ARRAY_SOURCE_DECLARATION) + target_compile_definitions(blosc2_ext PRIVATE B2_HAVE_GRAPH_SOURCES=1) + endif() + endif() + FetchContent_GetProperties(yyjson SOURCE_DIR B2_YYJSON_SOURCE_DIR) + install(FILES "${B2_YYJSON_SOURCE_DIR}/LICENSE" + DESTINATION ${SKBUILD_METADATA_DIR}/licenses/miniexpr RENAME LICENSE-YYJSON) +endif() if(APPLE) target_link_libraries(blosc2_ext PRIVATE "-framework Accelerate") endif() diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md index 1d7bd308c..08305a732 100644 --- a/RELEASE_NOTES.md +++ b/RELEASE_NOTES.md @@ -1,5 +1,79 @@ # Release notes +## Changes from 4.14.2 to 4.15.0 (in development) + +### Introducing the Menudet 1.0 draft + +**Menudet — a little language for portable computation on arrays and tables.** + +- Strengthen NumExpr-removal qualification: runtime/install behavior is independent + of NumExpr, including native interpretation without JIT. Nullable + `blosc2.numexpr` remains a compatibility surface, not an engine selector. + - Native compression/reduction prefilter failures now propagate instead of + replaying a partially executed operation through NumPy. + - Serial bounded stored-output maps accept interpreter artifacts as well as JIT. + - CI requires NumExpr-free environments; comparison tooling treats it as optional. +- Use native structural classification for automatic execution policy: interpret + single-return expressions and prefer JIT for multi-statement Menudet programs. + Explicit JIT settings and source compiler pragmas retain priority. Expose + `PortableKernel.execution_kind`; `evaluate()` no longer needs a special default + override. This requires the paired native classification API; older runtimes + retain their existing default behavior. Remove the legacy + `truediv`, `sanitize` and `disable_cache` keywords; supplying them now raises an + error. Keep `order`, `casting` and the `optimization` compatibility hint. +- Enable complex64/complex128 miniexpr expressions and Menudet interpretation + on Windows (clang-cl), and remove the remaining WebAssembly complex expression + and reduction exclusions. Complex Menudet kernels remain interpreter-only. + Scalar string-expression reductions on WASM retain the existing chunked + fallback for all dtypes; portable Menudet block reductions remain supported. +- C-order `arange` with real bounds and complex output, and complex `linspace`, + now use Menudet interpretation, including `lazy=True`. Complex `linspace` + preserves the requested endpoint across slicing and rechunking. +- Menudet source pragmas now select math libraries and floating-point modes: + `me:math=auto|system|sleef|accelerate`, `me:ulp=u10|u35`, and + `me:fp=strict|contract|fast` (with `me:compiler=cc`). Exported artifacts + preserve explicit policy through JSON round trips; omitted fields inherit + `ME_SIMD_MATH_BACKEND`/`ME_DSL_FP_MODE` at preparation. Unavailable explicit + backends fail before execution, and `auto` now follows system math instead of + preferring SLEEF. +- Export normalized `DSLKernel` authoring as validated, standalone JSON artifacts + with typed signatures and exact captured constants. Native miniexpr executes + imports without reconstructing Python functions or falling back to Python. +- Support checked integer arithmetic, operand-typed floating computation, control + flow, fixed-width strings, logical array coordinates and ordered block reductions. +- Keep logical reduction groups stable through persistence, partial reads and + output rechunking. True block-scalar results expose the logical block-grid shape. +- Validate kernel inputs to `CTable.add_computed_column()` and + `add_generated_column()` as Menudet artifacts with implicit independent-row + semantics, including fixed-shape row reductions. Named bindings are supported; + positional bindings and column-bound DSL LazyUDFs adopt the same semantics. + New cross-row computations must use array partitions or table aggregation, + rather than implicit execution blocks or append batches. +- Remove the draft `add_portable_*` column methods and `row_domain` argument. + Fixed-shape row reductions use `cardinality="block_scalar"`. +- New compliant DSLKernel-backed LazyUDF saves export the draft automatically; + unsupported saves fail validation before writing the destination. +- Historical Python-specific recipes require explicit `deserialize="full"`. + MessagePack decoding is safe by default, including nested containers. +- Saved legacy table-kernel recipes retain their old block/batch-dependent + behavior only with trusted, explicit `deserialize="full"`; safe-mode errors + explain the opt-in. Recipes are never automatically reinterpreted. +- Ordinary LazyExpr persistence retains supported numerical calls, reductions, + methods and indexing under default loading, with existing expression validation. + Full-only nested payloads remain gated. String/lazy expressions and non-kernel + row transformers retain their existing table registration behavior. + +Menudet 1.0 is a **draft**, not a frozen compatibility promise. The existing +`DSLKernel` and portable API names remain unchanged. This draft uses the typed +interpreter; optional JIT requests fall back before execution, while required JIT +rejects unsupported acceleration. Complex computation, callbacks, arbitrary +memory access and non-strict floating-point modes are outside the portable contract. + +See the [Menudet reference](https://www.blosc.org/python-blosc2/reference/portable_dsl.html) +for array/table examples, persistence policy and current limitations. Release +certification is tracked separately; this development entry is not an announcement +that 4.15.0 has been published. + ## Changes from 4.14.1 to 4.14.2 XXX version-specific blurb XXX diff --git a/bench/evaluate-numpy-parity.py b/bench/evaluate-numpy-parity.py new file mode 100644 index 000000000..77afad906 --- /dev/null +++ b/bench/evaluate-numpy-parity.py @@ -0,0 +1,345 @@ +"""Compare NumPy, optional NumExpr and evaluate with warmed, explicit NumPy out. + +Both public APIs are called on every sample. Correctness, output identity and +output casting qualify each engine before timing. NumPy expressions may allocate +intermediates before copying to out; Blosc2 reports its executed native route. +There is no decompression in this resident benchmark. Route probes run untimed. +""" + +import argparse +import hashlib +import importlib +import json +import os +import platform +import random +import sys +from math import prod +from pathlib import Path +from statistics import median +from time import perf_counter +from unittest.mock import patch + +import numpy as np + +import blosc2 + +try: + import numexpr as ne +except ImportError: + ne = None + +RECIPES = { + "linear": "x + y * 2 - 1", + "polynomial": "x * x + y * y + x * y", + "division": "x / (y + 1)", + "power": "x ** y", + "sqrt": "sqrt(x * x + y * y)", + "trig": "sin(x) + cos(y)", + "log-exp": "log1p(x) + expm1(y)", + "hypot": "hypot(x, y)", + "fmod": "fmod(y, x + 0.1)", + "round": "floor(x * 3) + ceil(y)", + "predicate": "isfinite(x) & (x < y)", + "where": "where(x > 0.5, x + y, x - y)", + "minimum": "minimum(x, y)", + "maximum": "maximum(x, y)", + "extrema-chain": "minimum(maximum(x, y), x + 2)", + "copy": "copy(x)", + "sum": "sum(x * y)", + "complex": "complex(x, y)", +} + + +def make_inputs(size, dtype): + if np.dtype(dtype).kind in "iu": + return {"x": np.arange(size, dtype=dtype) % 97 + 1, "y": np.arange(size, dtype=dtype) % 31 + 1} + return {"x": np.linspace(0.1, 0.9, size, dtype=dtype), "y": np.linspace(1.1, 1.9, size, dtype=dtype)} + + +def execution_route(operation, *, return_report=False): + native = importlib.import_module("blosc2.native_graph") + original_native = native.compute_native_graph + original_specialize = blosc2.NativeGraph.specialize + observed = set() + reports = [] + + def record(report): + reports.append( + { + key: report[key] + for key in ( + "temporary_bytes", + "gathered_bytes", + "scattered_bytes", + "intermediate_bytes", + "maximum_input_items", + "tasks", + "output_copy_bytes", + "input_materialization_bytes", + "jit_stages", + "interpreter_stages", + ) + if key in report + } + ) + if report.get("jit_stages", 0): + observed.add("native-jit") + elif report.get("interpreter_stages", 0): + observed.add("native-interpreter") + elif report.get("backend"): + observed.add("native-jit" if report["backend"] == "portable-jit" else "native-interpreter") + else: + observed.add("native-copy") + + def native_call(*args, **kwargs): + result = original_native(*args, **kwargs) + if result is not None: + record(getattr(args[0], "_native_execution_report", {})) + return result + + class ScheduleProbe: + def __init__(self, schedule): + self.schedule = schedule + + def __getattr__(self, name): + return getattr(self.schedule, name) + + def execute(self, *args, **kwargs): + result = self.schedule.execute(*args, **kwargs) + record(result[1]) + return result + + def execute_sources(self, *args, **kwargs): + result = self.schedule.execute_sources(*args, **kwargs) + record(result[1]) + return result + + def specialize(*args, **kwargs): + return ScheduleProbe(original_specialize(*args, **kwargs)) + + with ( + patch.object(native, "compute_native_graph", native_call), + patch.object(blosc2.NativeGraph, "specialize", specialize), + ): + operation() + route = "+".join(sorted(observed)) if observed else "numpy/eager" + return (route, reports) if return_report else route + + +def numpy_evaluate(expression, inputs, out=None, order="K"): + """Independent NumPy reference for the script's fixed recipe vocabulary.""" + + if expression == "copy(x)" and out is not None: + np.copyto(out, inputs["x"], casting="same_kind") + return out + + def complex_parts(real, imag): + real, imag = np.broadcast_arrays(real, imag) + result = np.empty(real.shape, dtype="complex128") if out is None else out + result.real, result.imag = real, imag + return result + + names = { + name: getattr(np, name) + for name in ( + "sqrt", + "sin", + "cos", + "log1p", + "expm1", + "hypot", + "fmod", + "floor", + "ceil", + "isfinite", + "where", + "minimum", + "maximum", + "ones_like", + "sum", + ) + } + names.update(copy=lambda x: np.array(x, copy=True, order=order), complex=complex_parts) + result = np.asarray(eval(expression, {"__builtins__": {}, **names}, inputs)) + if out is not None: + if result is not out: + np.copyto(out, result, casting="same_kind") + return out + return result + + +def assert_reference(actual, reference): + if reference.dtype.kind in "biu": + np.testing.assert_array_equal(actual, reference) + else: + np.testing.assert_allclose( + actual, + reference, + rtol=2e-6 if reference.dtype.itemsize <= 4 else 2e-12, + atol=2e-7 if reference.dtype.itemsize <= 4 else 2e-12, + ) + + +def compare_case(expression, inputs, samples, warmups, rng, order="K"): + options = {} if order == "K" else {"order": order} + reference = numpy_evaluate(expression, inputs, order=order) + # Numerical values alone cannot qualify a timing with different result + # promotion. NumPy defines the contract; a non-equivalent optional NumExpr + # reference becomes N/A without excluding a qualified Blosc2/NumPy case. + native_dtype = blosc2.evaluate(expression, local_dict=inputs).dtype + if native_dtype != reference.dtype: + raise TypeError(f"result dtype differs: Blosc2 {native_dtype}, NumPy {reference.dtype}") + output = np.empty_like(reference, order=order) + operations = { + "numpy": lambda: numpy_evaluate(expression, inputs, out=output, order=order), + "blosc2": lambda: blosc2.evaluate(expression, local_dict=inputs, out=output, **options), + } + reference_error = None + if ne is not None: + try: + external = ne.evaluate(expression, local_dict=inputs, **options) + if external.dtype != reference.dtype: + raise TypeError(f"result dtype differs: NumExpr {external.dtype}, NumPy {reference.dtype}") + assert_reference(external, reference) + if ne.evaluate(expression, local_dict=inputs, out=output, **options) is not output: + raise AssertionError("NumExpr did not return the supplied destination") + operations["numexpr"] = lambda: ne.evaluate(expression, local_dict=inputs, out=output, **options) + except Exception as error: + reference_error = f"{type(error).__name__}: {error}" + for operation in operations.values(): + result = operation() + if result is not output: + raise AssertionError("The public API did not return the supplied destination") + assert_reference(result, reference) + del reference + for _ in range(warmups): + for operation in operations.values(): + operation() + route, reports = execution_route(operations["blosc2"], return_report=True) + times = {name: [] for name in operations} + for _ in range(samples): + names = list(operations) + rng.shuffle(names) + for name in names: + start = perf_counter() + operations[name]() + times[name].append((perf_counter() - start) * 1000) + values = {name: median(measurements) for name, measurements in times.items()} + return { + **values, + "numexpr": values.get("numexpr"), + "numexpr_error": reference_error, + "ratio": values["blosc2"] / values["numexpr"] if "numexpr" in values else None, + "route": route, + "execution_reports": reports, + "output_bytes": output.nbytes, + "spread_ms": {name: max(samples) - min(samples) for name, samples in times.items()}, + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--items", type=int, nargs="+", default=[100_000, 8_000_000]) + parser.add_argument( + "--shape", type=int, nargs="+", help="one explicit multidimensional case; overrides items" + ) + parser.add_argument("--input-order", choices=["C", "F"], default="C") + parser.add_argument("--order", choices=["C", "F", "A", "K"], default="K") + parser.add_argument("--dtype", choices=["float32", "float64", "int64"], default="float64") + parser.add_argument("--cases", nargs="+", choices=tuple(RECIPES), default=list(RECIPES)) + parser.add_argument("--threads", type=int, default=8) + parser.add_argument("--samples", type=int, default=5) + parser.add_argument("--warmups", type=int, default=3) + parser.add_argument("--jit", choices=["tcc", "cc"], default="cc") + parser.add_argument("--backend", choices=["auto", "interpreter", "jit"], default="auto") + parser.add_argument("--json", help="also save classifications, medians and runtime versions") + parser.add_argument("--native-revision", help="explicit revision used to build the measured extension") + args = parser.parse_args() + if args.shape: + if min(args.shape) <= 0: + parser.error("shape extents must be positive") + args.items = [prod(args.shape)] + if min(args.items) <= 0 or args.samples <= 0 or args.warmups < 0 or args.threads <= 0: + parser.error("items, samples and threads must be positive; warmups must be nonnegative") + os.environ["ME_DSL_JIT_COMPILER"] = args.jit + if args.backend != "auto": + os.environ["ME_DSL_JIT"] = "0" if args.backend == "interpreter" else "1" + blosc2.set_jit_options(jit=args.backend == "jit") + blosc2.set_nthreads(args.threads) + if ne is not None: + ne.set_num_threads(args.threads) + print( + f"NumPy {np.__version__} | NumExpr {ne.__version__ if ne is not None else 'unavailable'} | Blosc2 {blosc2.__version__}" + f" | {args.dtype} | threads {args.threads} | backend {args.backend} | compiler {args.jit}" + ) + probe = blosc2.NativeGraph.from_expression("x + 1", {"x": args.dtype}, jit=True) + print( + f"Native JIT available/enabled: {probe.has_jit}; identity maps may use native copies without a kernel." + ) + if args.backend == "jit" and not probe.has_jit: + parser.error("JIT was requested but is unavailable") + print("Resident inputs; shared warmed NumPy out; public API preparation/rebinding included.") + print(f"Input order {args.input_order}; destination order {args.order}; shape {args.shape or 'flat'}") + print( + f"{'case':<14} {'items':>10} {'numpy ms':>12} {'numexpr ms':>12} {'blosc2 ms':>12} {'BL/NE':>8} route" + ) + records = [] + rng = random.Random(42) + for size in args.items: + inputs = make_inputs(size, args.dtype) + if args.shape: + inputs = { + name: np.array(value.reshape(args.shape), order=args.input_order, copy=True) + for name, value in inputs.items() + } + for name in args.cases: + record = {"case": name, "expression": RECIPES[name], "items": size, "dtype": args.dtype} + try: + result = compare_case( + RECIPES[name], inputs, args.samples, args.warmups, rng, order=args.order + ) + record.update(status="qualified", **result) + external = f"{result['numexpr']:.3f}" if result["numexpr"] is not None else "N/A" + ratio = f"{result['ratio']:.2f}" if result["ratio"] is not None else "N/A" + print( + f"{name:<14} {size:>10} {result['numpy']:>12.3f} {external:>12} {result['blosc2']:>12.3f}" + f" {ratio:>8} {result['route']}", + flush=True, + ) + except Exception as error: + record.update(status="unqualified", error=f"{type(error).__name__}: {error}") + print( + f"{name:<14} {size:>10} {'N/A':>12} {'N/A':>12} {'N/A':>12} {'N/A':>8} unqualified", + flush=True, + ) + records.append(record) + del inputs + if args.json: + with open(args.json, "w") as stream: + json.dump( + { + "versions": { + "numpy": np.__version__, + "numexpr": ne.__version__ if ne is not None else None, + "blosc2": blosc2.__version__, + }, + "configuration": vars(args), + "platform": platform.platform(), + "python": sys.version, + "native_probe_has_jit": probe.has_jit, + "package": blosc2.__file__, + "extension_sha256": hashlib.sha256( + Path(blosc2.blosc2_ext.__file__).read_bytes() + ).hexdigest(), + "numpy_temporaries": "Chained recipes allocate intermediates; copy and complex write directly to out.", + "results": records, + }, + stream, + indent=2, + ) + stream.write("\n") + + +if __name__ == "__main__": + main() diff --git a/bench/jit-coverage.py b/bench/jit-coverage.py new file mode 100644 index 000000000..82f5ee41b --- /dev/null +++ b/bench/jit-coverage.py @@ -0,0 +1,556 @@ +####################################################################### +# Copyright (c) 2019-present, Blosc Development Team +# All rights reserved. +# SPDX-License-Identifier: BSD-3-Clause +####################################################################### +"""Measure portable JIT coverage, correctness, cold load and warm execution. + +Run from an environment built with the experimental Menudet native revision:: + + python bench/jit-coverage.py --items 4096 --repeat 5 + python bench/jit-coverage.py --case 'loop/*' --backends tcc clang + python bench/jit-coverage.py --json results.json --require-jit + +This benchmarks production PortableKernel artifacts on NumPy buffers, not +compression, lazy scheduling or legacy @blosc2.jit dispatch. Cases intentionally +include safe fallbacks. Cold timing includes artifact load/JIT preparation, not +source export; existing compiler caches can make it a cached load, not a fresh +compile. Warm timing includes the Python adapter and output allocation. A prepared +kernel's has_jit flag identifies the route for these direct, nonempty evaluations. +""" + +from __future__ import annotations + +import argparse +import fnmatch +import json +import os +import platform +import shutil +import statistics +import subprocess +import sys +import time +from contextlib import contextmanager +from dataclasses import dataclass, field +from pathlib import Path + +import numpy as np + +import blosc2 + + +@dataclass(frozen=True) +class Case: + name: str + body: str + inputs: dict[str, str] = field(default_factory=lambda: {"x": "float64", "y": "float64"}) + output: str = "float64" + constants: dict = field(default_factory=dict) + cardinality: str = "elementwise" + data: str = "normal" + masked: bool = False + expect_jit: bool = True + + def source(self): + arguments = ", ".join([*self.inputs, *self.constants]) + return f"def k({arguments}):\n " + self.body.replace("\n", "\n ") + "\n" + + +FLOAT = {"x": "float64", "y": "float64"} +INT = {"x": "int32", "y": "int32"} +CASES = [ + Case("arithmetic/float64", "return x * 2 + y"), + Case("arithmetic/float32", "return x * 2 + y", {"x": "float32", "y": "float32"}, "float32"), + Case("arithmetic/int32", "return x * 2 + y", INT, "int32"), + Case("arithmetic/mod", "return x % 7", INT, "int32"), + Case("arithmetic/shift", "return x << 2", INT, "int32"), + Case("arithmetic/floordiv", "return x // 3.0"), + Case("arithmetic/power", "return x ** 2.5", data="positive"), + Case("compare/int64-exact", "return x < y", {"x": "int64", "y": "int64"}, "bool", data="exact"), + Case("compare/mixed-domains", "return x < y", {"x": "int64", "y": "uint64"}, "bool", data="exact"), + Case("flow/locals", "z = x * 2\nreturn z + y"), + Case("flow/conditional-return", "if x > 0:\n return x\nreturn -x"), + Case("flow/live-join", "if x < 0:\n return x\nelse:\n z = x + y\nreturn z"), + Case("flow/elif", "if int(x) > 0:\n return x\nelif int(y) > 0:\n return y\nreturn 0.0"), + Case("flow/where", "return where(x > 0, int(y), 0)", output="int64", data="lazy-cast"), + Case("flow/and", "return x > 0 and int(y) > 0", output="bool", data="lazy-cast"), + Case("flow/or", "return x <= 0 or int(y) > 0", output="bool", data="lazy-cast"), + Case("loop/range", "s = 0.0\nfor i in range(16):\n s = s + x\nreturn s"), + Case("loop/float-range", "s = 0.0\nfor i in range(abs(x) * 4):\n s = s + i\nreturn s"), + Case( + "loop/uint-range", + "s = 0\nfor i in range(x):\n s = s + i\nreturn s", + {"x": "uint64"}, + "int64", + data="cast", + ), + Case("loop/negative-range", "s = 0.0\nfor i in range(15, -1, -2):\n s = s + x\nreturn s"), + Case("loop/while", "s = 0.0\ni = 0\nwhile i < 16:\n s = s + x\n i = i + 1\nreturn s"), + Case( + "loop/break", "s = 0.0\nfor i in range(16):\n if s > y:\n break\n s = s + x\nreturn s" + ), + Case( + "loop/continue", + "s = 0.0\nfor i in range(16):\n if i < 3:\n continue\n s = s + x\nreturn s", + ), + Case("loop/return", "for i in range(16):\n if x > 0:\n return x\nreturn y"), + Case("loop/nested", "s = 0.0\nfor i in range(4):\n for j in range(4):\n s = s + x\nreturn s"), + Case( + "loop/nested-exits", + "s = 0.0\nfor i in range(4):\n for j in range(4):\n if j == 1:\n" + " continue\n if j == 3:\n break\n s = s + x\nreturn s", + ), + Case( + "loop/while-continue", + "s = 0.0\ni = 0\nwhile i < 16:\n i = i + 1\n if i < 3:\n" + " continue\n s = s + x\nreturn s", + ), + Case( + "loop/mandelbrot", + "zr = 0.0\nzi = 0.0\nn = 0\nfor i in range(limit):\n" + " if zr * zr + zi * zi > 4.0:\n break\n" + " new_zr = zr * zr - zi * zi + x\n zi = 2 * zr * zi + y\n" + " zr = new_zr\n n = n + 1\nreturn n", + output="int64", + constants={"limit": 64}, + data="mandelbrot", + ), + *[ + Case(f"cast/{cast}", f"return {cast}(x)", output=cast, data="cast") + for cast in ("int8", "uint8", "int32", "uint32", "int64", "uint64") + ], + *[ + Case(f"integer-math/{name}", f"return {name}(x)", INT, "int32") + for name in ("abs", "sign", "square", "floor", "ceil", "trunc", "round", "real", "imag", "conj") + ], + *[ + Case(f"integer-math/{name}", f"return {expression}", INT, "int32", data="combinatorial") + for name, expression in ( + ("factorial", "fac(x)"), + ("ncr", "ncr(x, y)"), + ("npr", "npr(x, y)"), + ("power", "x ** y"), + ) + ], + Case("math/unary", "return sin(x) + cos(y)"), + Case("math/binary", "return hypot(x, y)"), + Case("math/ldexp", "return ldexp(x, 2)"), + Case("math/fma", "return fma(x, y, 1.0)"), + Case("math/fp-status", "return sqrt(x)"), + Case("weak/integer-leaf", "return x + c", {"x": "int8"}, "int8", {"c": 7}), + Case("weak/computed", "return x + (c + 1)", {"x": "int8"}, "int8", {"c": 7}), + Case("weak/floating-cast", "return x + int8(c)", {"x": "int8"}, "int8", {"c": 7.75}), + Case("mask/arithmetic", "return x * 2 + y", masked=True), + Case("mask/checked-cast", "return int64(x)", output="int64", data="masked-cast", masked=True), + Case("mask/loops", "s = 0.0\nfor i in range(16):\n s = s + x\nreturn s", masked=True), + *[ + Case(f"reduction/{name}", f"return {body}", cardinality="block_scalar", data="positive") + for name, body in ( + ("sum-direct", "block_sum(x)"), + ("sum-map", "block_sum(x * 2)"), + ("prod-direct", "block_prod(x)"), + ("prod-map", "block_prod(x + y)"), + ("sum-math", "block_sum(sin(x))"), + ) + ], + Case("reduction/masked-map", "return block_sum(x * 2)", cardinality="block_scalar", masked=True), + Case("reduction/sum-post", "return block_sum(x * 2) / 2", cardinality="block_scalar"), + Case("reduction/scalar-statements", "s = block_sum(x)\nreturn s + 1", cardinality="block_scalar"), + Case( + "reduction/scalar-locals", + "a = 2.0\ns = block_sum(x * a)\nreturn s / a", + cardinality="block_scalar", + ), + Case("reduction/mean-direct", "return block_mean(x)", cardinality="block_scalar"), + Case("reduction/mean-map", "return block_mean(x * 2)", cardinality="block_scalar"), + Case("reduction/mean-post", "s = block_mean(x * 2)\nreturn s / 2", cardinality="block_scalar"), + *[ + Case(f"reduction/{op}-direct", f"return block_{op}(x)", cardinality="block_scalar") + for op in ("min", "max") + ], + *[ + Case(f"reduction/{op}-map", f"return block_{op}(x * 2)", cardinality="block_scalar") + for op in ("min", "max") + ], + *[ + Case(f"reduction/{op}-direct", f"return block_{op}(x)", output="bool", cardinality="block_scalar") + for op in ("any", "all") + ], + *[ + Case(f"reduction/{op}-map", f"return block_{op}(x > 0)", output="bool", cardinality="block_scalar") + for op in ("any", "all") + ], + Case("reduction/min-int32-map", "return block_min(x * 2)", INT, "int32", cardinality="block_scalar"), + Case("reduction/max-post", "s = block_max(x * 2)\nreturn s / 2", cardinality="block_scalar"), + Case( + "reduction/integer-sum", + "return block_sum(x)", + INT, + "int64", + cardinality="block_scalar", + ), + Case( + "reduction/multiple-sums", + "return block_sum(x) + block_sum(y)", + cardinality="block_scalar", + ), + Case("reduction/ratio", "return block_sum(x) / block_sum(y)", cardinality="block_scalar"), + Case( + "reduction/scalar-if", + "s = block_sum(x)\nif s > 0:\n return block_mean(y)\nreturn s", + cardinality="block_scalar", + ), + Case( + "reduction/scalar-elif", + "s = block_sum(x)\nif s > 0:\n return block_max(y)\nelif s < 0:\n return block_min(y)\nreturn s", + cardinality="block_scalar", + ), + Case("reduction/integer-sum-map", "return block_sum(x * 2)", INT, "int64", cardinality="block_scalar"), + Case( + "reduction/integer-prod-map", + "return block_prod(x - x + 1)", + INT, + "int64", + cardinality="block_scalar", + ), + Case( + "reduction/integer-mean", + "return block_mean(x)", + INT, + "float64", + cardinality="block_scalar", + ), + Case( + "reduction/integer-mean-map", "return block_mean(x * 2)", INT, "float64", cardinality="block_scalar" + ), + Case( + "reduction/integer-mean-post", + "m = block_mean(x)\nreturn m / 2", + INT, + "float64", + cardinality="block_scalar", + ), + Case( + "reduction/array-local", + "v = x * 2\nreturn block_sum(v)", + cardinality="block_scalar", + ), + Case( + "reduction/scalar-for", + "s = block_sum(x)\nfor i in range(3):\n s = s + i\nreturn s", + cardinality="block_scalar", + ), + Case( + "reduction/scalar-while", + "s = block_mean(x)\nj = 0\nwhile j < 3:\n j = j + 1\n s = s + 1\nreturn s", + cardinality="block_scalar", + ), + Case( + "reduction/array-locals-reused", + "v = x * 2\nw = v + x\nreturn block_sum(v) + block_mean(w)", + cardinality="block_scalar", + ), + Case( + "fallback/branch-array-local", + "s = block_sum(x)\nif s > 0:\n v = x\nelse:\n v = x * 2\nreturn block_sum(v)", + cardinality="block_scalar", + expect_jit=False, + ), + Case( + "fallback/loop-array-local", + "v = x\nfor i in range(3):\n v = v * 2\nreturn block_sum(v)", + cardinality="block_scalar", + expect_jit=False, + ), +] + + +def operands(case, count): + index = np.arange(count) + x = (index % 31 - 15) / 8 + y = (index % 17 - 8) / 4 + if case.data == "positive": + # Near-one products avoid making overflow the only measured workload. + x = 1 + (index % 7 - 3) * 1e-5 + y = (index % 5 - 2) * 1e-5 + elif case.data == "cast": + x = (index % 127) + 0.75 + elif case.data == "combinatorial": + x = index % 8 + y = np.minimum(index % 3, x) + elif case.data == "mandelbrot": + width = max(1, int(np.sqrt(count))) + x = -2 + 3 * (index % width) / max(1, width - 1) + y = -1.5 + 3 * (index // width) / max(1, (count - 1) // width) + elif case.data == "exact": + x = np.resize(np.array([-(2**63), -1, 0, 2**53, 2**63 - 1], dtype="int64"), count) + values = ( + [0, 2**64 - 1, 0, 2**53 + 1, 2**64 - 1] + if case.inputs["y"] == "uint64" + else [-(2**63), 0, -1, 2**53 + 1, 2**63 - 1] + ) + y = np.resize(np.array(values, dtype=case.inputs["y"]), count) + elif case.data == "lazy-cast": + y = np.where(x > 0, 2.75, np.nan) + elif case.data == "masked-cast": + x = np.where(index % 3 != 0, 2.75, np.nan) + values = {"x": x, "y": y} + arrays = {name: np.asarray(values[name], dtype=dtype) for name, dtype in case.inputs.items()} + mask = np.asarray(index % 3 != 0) if case.masked else None + return arrays, mask + + +@contextmanager +def backend_environment(backend, compiler): + changes = {"ME_DSL_JIT_COMPILER": "tcc" if backend == "tcc" else "cc"} + if compiler: + changes["CC"] = compiler + previous = {key: os.environ.get(key) for key in changes} + os.environ.update(changes) + try: + yield + finally: + for key, value in previous.items(): + if value is None: + os.environ.pop(key, None) + else: + os.environ[key] = value + + +def compiler_for(backend, args): + if backend == "tcc": + return None # Bundled libtcc need not provide a tcc executable on PATH. + requested = getattr(args, backend) + candidates = ( + (requested,) + if requested + else (("gcc-16", "gcc-15", "gcc-14", "gcc") if backend == "gcc" else ("clang",)) + ) + for candidate in candidates: + path = shutil.which(candidate) + if not path: + continue + version = subprocess.run([path, "--version"], capture_output=True, text=True, check=False) + description = (version.stdout + version.stderr).lower() + # macOS /usr/bin/gcc is Clang, not a separate GCC backend. + if (backend == "gcc" and "clang" not in description) or ( + backend == "clang" and "clang" in description + ): + return path + return None + + +def check_result(actual, expected, mask, cardinality): + actual, expected = np.asarray(actual), np.asarray(expected) + if actual.dtype != expected.dtype or actual.shape != expected.shape: + raise AssertionError( + f"result signature differs: {actual.dtype}/{actual.shape}, {expected.dtype}/{expected.shape}" + ) + if mask is not None and cardinality == "elementwise": + # Nonparticipating output lanes have unspecified contents. + actual, expected = actual[mask], expected[mask] + np.testing.assert_array_equal(actual, expected) + if actual.dtype.kind == "f": + participating = ~np.isnan(expected) + # Keep signed-zero and rounding checks; NaN payload/sign is not portable. + if actual[participating].tobytes() != expected[participating].tobytes(): + raise AssertionError("non-NaN floating result bits differ") + + +def measure(kernel, arrays, mask, repeat): + def evaluate(): + return kernel.evaluate_block(arrays, valid_mask=mask) + + evaluate() # Warm-up is outside reported timings. + samples = [] + for _ in range(repeat): + start = time.perf_counter_ns() + evaluate() + samples.append((time.perf_counter_ns() - start) / 1e6) + return {"best_ms": min(samples), "median_ms": statistics.median(samples), "samples_ms": samples} + + +def benchmark_reference(case, arrays, mask, repeat): + artifact = blosc2.DSLKernel.from_source(case.source()).export( + case.inputs, + case.output, + constants=case.constants, + version="1.0", + cardinality=case.cardinality, + ) + start = time.perf_counter_ns() + reference = blosc2.PortableKernel.from_json(artifact, jit=False) + cold = (time.perf_counter_ns() - start) / 1e6 + expected, status = reference.evaluate_block(arrays, valid_mask=mask, return_status=True) + return ( + artifact, + expected, + status, + { + "route": "interpreter", + "cold_load_ms": cold, + "fp_status": status, + **measure(reference, arrays, mask, repeat), + }, + ) + + +def benchmark_backend(case, artifact, arrays, mask, expected, expected_status, backend, compiler, args): + if backend != "tcc" and compiler is None: + return {"route": "unavailable"} + try: + with backend_environment(backend, compiler): + start = time.perf_counter_ns() + kernel = blosc2.PortableKernel.from_json(artifact, jit=True) + cold = (time.perf_counter_ns() - start) / 1e6 + actual, status = kernel.evaluate_block(arrays, valid_mask=mask, return_status=True) + check_result(actual, expected, mask, case.cardinality) + if status != expected_status: + raise AssertionError(f"FP status differs: {status} != {expected_status}") + route = "jit" if kernel.has_jit else "fallback" + return { + "route": route, + "cold_load_ms": cold, + "fp_status": status, + **measure(kernel, arrays, mask, args.repeat), + } + except Exception as error: + return {"route": "invalid", "error": str(error)} + + +def print_row(record, backends, color): + reference = record["interpreter"]["median_ms"] + medians = [reference] + cells = [f"{reference:.3f} I"] + for backend in backends: + result = record["backends"][backend] + if "median_ms" in result: + ms = result["median_ms"] + medians.append(ms) + cells.append(f"{ms:.3f} {'JIT' if result['route'] == 'jit' else 'fb'} {reference / ms:.1f}x") + else: + medians.append(float("inf")) + cells.append(result["route"]) + fastest = min(range(len(medians)), key=medians.__getitem__) + rendered = [] + for index, cell in enumerate(cells): + cell = f"{cell:>{14 if index == 0 else 24}s}" + rendered.append(f"\033[1;32m{cell}\033[0m" if color and index == fastest else cell) + print(f"{record['case']:34s}" + " ".join(rendered), flush=True) + + +def main(): + parser = argparse.ArgumentParser( + description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter + ) + parser.add_argument("--items", type=int, default=4096) + parser.add_argument("--repeat", type=int, default=5) + parser.add_argument( + "--backends", nargs="+", choices=("tcc", "gcc", "clang"), default=["tcc", "gcc", "clang"] + ) + parser.add_argument("--gcc", help="GCC executable (auto-detected by default)") + parser.add_argument("--clang", help="Clang executable (auto-detected by default)") + parser.add_argument( + "--case", action="append", default=[], help="case-name glob; repeat to select multiple families" + ) + parser.add_argument("--list", action="store_true", help="list selected cases without loading kernels") + parser.add_argument( + "--require-jit", + action="store_true", + help="fail if an expected eligible case falls back or a backend is missing", + ) + parser.add_argument("--json", type=Path, help="write timings, routes and environment metadata") + args = parser.parse_args() + if args.items < 1 or args.repeat < 1: + parser.error("--items and --repeat must be positive") + selected = [ + case + for case in CASES + if not args.case or any(fnmatch.fnmatchcase(case.name, pattern) for pattern in args.case) + ] + if not selected: + parser.error("no cases match --case") + if args.list: + for case in selected: + print(f"{case.name:34s} expected={'jit' if case.expect_jit else 'fallback'}") + return 0 + backends = list(dict.fromkeys(args.backends)) + compilers = {backend: compiler_for(backend, args) for backend in backends} + metadata = { + "python": sys.version, + "platform": platform.platform(), + "blosc2": blosc2.__version__, + "numpy": np.__version__, + "items": args.items, + "repeat": args.repeat, + "compilers": compilers, + "environment": { + key: os.environ.get(key) + for key in ("CFLAGS", "ME_DSL_JIT_TCC_OPTIONS", "ME_DSL_JIT_CACHE_DIR", "ME_DSL_WHILE_MAX_ITERS") + }, + } + records = [] + failures = [] + totals = {backend: {"jit": 0, "fallback": 0, "unavailable": 0, "invalid": 0} for backend in backends} + color = "NO_COLOR" not in os.environ and (sys.stdout.isatty() or os.environ.get("FORCE_COLOR") == "1") + print(f"Portable JIT coverage: {len(selected)} cases, {args.items} items, {args.repeat} warm samples") + print( + "Cells: median ms [JIT/fb], speedup vs interpreter; cold load ms in JSON. Fastest valid median highlighted." + ) + print( + "C/JIT caches are preserved; cold load may reuse cached code. Nonparticipating lanes are not compared." + ) + for backend, compiler in compilers.items(): + print(f"{backend}: {compiler or ('bundled/runtime libtcc' if backend == 'tcc' else 'unavailable')}") + print(f"{'case':34s} {'interpreter':>14s}" + "".join(f"{backend:>24s}" for backend in backends)) + for case in selected: + arrays, mask = operands(case, args.items) + try: + artifact, expected, expected_status, timing = benchmark_reference( + case, arrays, mask, args.repeat + ) + except Exception as error: + raise RuntimeError(f"{case.name}: interpreter reference failed: {error}") from error + record = { + "case": case.name, + "expected_jit": case.expect_jit, + "source": case.source(), + "inputs": case.inputs, + "output": case.output, + "constants": case.constants, + "cardinality": case.cardinality, + "masked": case.masked, + "interpreter": timing, + "backends": {}, + } + for backend in backends: + result = benchmark_backend( + case, artifact, arrays, mask, expected, expected_status, backend, compilers[backend], args + ) + if result["route"] == "invalid": + failures.append(f"{case.name}/{backend}: {result['error']}") + elif args.require_jit and case.expect_jit and result["route"] != "jit": + failures.append(f"{case.name}/{backend}: expected JIT, got {result['route']}") + totals[backend][result["route"]] += 1 + record["backends"][backend] = result + print_row(record, backends, color) + records.append(record) + print("\nRoute counts (selected cases, including intentional fallbacks):") + for backend, counts in totals.items(): + print(f" {backend}: " + ", ".join(f"{key}={value}" for key, value in counts.items())) + if args.json: + args.json.write_text( + json.dumps( + {"metadata": metadata, "cases": records, "route_counts": totals, "failures": failures}, + indent=2, + ) + + "\n" + ) + for failure in failures: + print(f"FAIL: {failure}", file=sys.stderr) + return int(bool(failures)) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/bench/mathlib-performance.py b/bench/mathlib-performance.py new file mode 100644 index 000000000..e6272fa9e --- /dev/null +++ b/bench/mathlib-performance.py @@ -0,0 +1,124 @@ +"""Benchmark integrated Menudet math backends and FP modes. + +Run in the blosc2 environment after rebuilding the extension against the matching +miniexpr. Reports warm evaluate() medians; no correlation with numerical audits. +""" + +from __future__ import annotations + +import argparse +import json +import statistics +import time + +import numpy as np + +import blosc2 +from blosc2.dsl_kernel import DSLKernel + +EXPRESSIONS = { + "sin+cos": "sin(x) + cos(x)", + "exp(sin)+log1p": "exp(sin(x)) + log1p(x + 1.5)", + "trig-heavy": "sin(x) * cos(x) + tan(x * 0.25)", + "sqrt-norm": "sqrt(x * x + 1.0)", +} + + +def measure(kernel, x, repeats): + kernel.evaluate({"x": x[:4096]}) + samples = [] + for _ in range(repeats): + start = time.perf_counter() + result = kernel.evaluate({"x": x}) + samples.append(time.perf_counter() - start) + return statistics.median(samples), result + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--items", type=int, default=2_000_000) + parser.add_argument("--repeats", type=int, default=9) + parser.add_argument("--jit", choices=["off", "on", "both"], default="both") + parser.add_argument("--output", default=None) + args = parser.parse_args() + + rng = np.random.default_rng(42) + x = rng.uniform(0.1, 2.0, args.items) + configurations = [ + ("system", None, "strict"), + ("system", None, "fast"), + ("sleef", "u10", "strict"), + ("sleef", "u10", "fast"), + ("sleef", "u35", "strict"), + ("sleef", "u35", "fast"), + ("accelerate", None, "strict"), + ("accelerate", None, "fast"), + ] + jit_modes = ["off", "on"] if args.jit == "both" else [args.jit] + rows = [] + for jit in jit_modes: + for name, expression in EXPRESSIONS.items(): + for math, ulp, fp in configurations: + try: + kernel = blosc2.PortableKernel.from_json( + DSLKernel.from_source( + f"# me:compiler=cc\n# me:math={math}\n# me:fp={fp}\n" + + (f"# me:ulp={ulp}\n" if ulp else "") + + f"def k(x):\n return {expression}\n" + ).export({"x": "float64"}, "float64"), + jit=jit == "on", + ) + except blosc2.PortableArtifactError as error: + rows.append( + { + "jit": jit, + "expression": name, + "math": math, + "ulp": ulp, + "fp": fp, + "error": str(error), + } + ) + continue + seconds, result = measure(kernel, x, args.repeats) + reference = eval( + expression, + { + "np": np, + "sin": np.sin, + "cos": np.cos, + "tan": np.tan, + "exp": np.exp, + "log1p": np.log1p, + "sqrt": np.sqrt, + }, + {"x": x}, + ) + error = float(np.max(np.abs(result - reference))) + rows.append( + { + "jit": jit, + "expression": name, + "math": math, + "ulp": ulp, + "fp": fp, + "ns_per_item": seconds * 1e9 / args.items, + "seconds": seconds, + "max_abs_error": error, + "backend": kernel._info.get("math_backend"), + "accuracy": kernel._info.get("sleef_accuracy"), + } + ) + print( + f"{jit:3} {name:16} {math:10} {ulp or '':3} {fp:6} " + f"{seconds * 1e3:8.2f} ms {rows[-1]['ns_per_item']:7.2f} ns/item " + f"{rows[-1]['backend']:10} {rows[-1]['accuracy']} err={error:.2e}" + ) + if args.output: + with open(args.output, "w") as handle: + json.dump(rows, handle, indent=2) + handle.write("\n") + + +if __name__ == "__main__": + main() diff --git a/bench/menudet-engines.py b/bench/menudet-engines.py new file mode 100644 index 000000000..bea5c6438 --- /dev/null +++ b/bench/menudet-engines.py @@ -0,0 +1,557 @@ +"""Compare compute engines for ``x + (y - 1)`` over NumPy and Blosc2 operands. + +A single human-readable table reports warm medians for the same expression +evaluated by NumPy, numexpr, both LazyExpr output paths, blosc2.evaluate and a Menudet kernel -- on +resident NumPy operands and on compressed Blosc2 operands (built with their +respective ``arange`` constructors). The fastest figure of every row is highlighted in green. + +For Blosc2 operands, NumPy and numexpr must first materialize (decompress) the +inputs, and that cost is included in their timings. Blosc2-output rows exercise +the existing compute paths, whose input materialization and scheduling may differ +from the NumPy-output paths. +The evaluate column calls ``blosc2.evaluate`` afresh each time. Repeated +preparation uses an operand-free recipe cache; input rebinding and fresh NumPy +output allocation are timed, and no result buffer is reused. The evaluate column +always returns NumPy output for elementwise expressions, as do NumPy, numexpr +and LazyExpr-NumPy. LazyExpr always returns Blosc2 output. Menudet returns Blosc2 +output for Blosc2 inputs and NumPy output for NumPy inputs. ``--codec`` and +``--clevel`` configure compressed inputs and outputs (defaults: zstd, 5). +Blosc2 outputs use the input chunk/block layout for Blosc2 inputs. +Engines with unsupported dtypes or different numerical results are reported as N/A. +``--warmups 0`` measures preparation-cold samples: expression and compiler caches +are isolated before every sample, and engine construction/compilation is timed. +Operand construction, imports and cache isolation are not timed; CPU/OS caches +are not flushed. Positive warmup counts retain prepared-engine warm measurements. +``--allocation-control`` adds a separate resident-input comparison of numexpr +and evaluate with fresh versus reused NumPy destinations. It does not change +the fresh-output policy of the main table. + +With ``--reduc``, each engine returns a scalar. Menudet uses a native block +reduction, which requires resident operands (decompression is timed for Blosc2). +Numexpr's mean is implemented as sum/count. Reduction threading depends on the +engine and is not necessarily the configured thread count. +Numexpr any/all use max/min of exact floating 0/1 truth values. + +Usage:: + + python bench/menudet-engines.py --items 100000 1000000 8000000 + python bench/menudet-engines.py --reduc sum + python bench/menudet-engines.py --jit cc + python bench/menudet-engines.py --dtype int16 --codec lz4 --clevel 3 + python bench/menudet-engines.py --dtype int64 --jit cc --allocation-control + +``--jit tcc|cc`` selects miniexpr's JIT compiler backend. With ``cc``, the +``CC`` environment variable selects the system compiler. Omitting ``--jit`` +preserves the existing environment/default backend selection. +""" + +import argparse +import importlib +import os +import random +import sys +import tempfile +from contextlib import contextmanager +from statistics import median +from time import perf_counter + +import numexpr as ne +import numpy as np + +import blosc2 + +EXPRESSION = "x + (y - 1)" +ENGINES = ("NumPy", "numexpr", "LazyExpr-NumPy", "LazyExpr", "evaluate", "Menudet") +GREEN = "\033[1;32m" +RESET = "\033[0m" + + +def human_items(count): + """Format an element count with a compact SI-style suffix (100K, 1M, 8M, 100M).""" + for suffix, factor in (("G", 1_000_000_000), ("M", 1_000_000), ("K", 1_000)): + if count >= factor: + value = f"{count / factor:.1f}".rstrip("0").rstrip(".") + return f"{value}{suffix}" + return str(count) + + +@blosc2.menudet +def adjusted(x, y): + return x + (y - 1) + + +@blosc2.menudet(cardinality="block_scalar") +def adjusted_sum(x, y): + return block_sum(x + (y - 1)) # noqa: F821 -- native DSL intrinsic + + +@blosc2.menudet(cardinality="block_scalar") +def adjusted_mean(x, y): + return block_mean(x + (y - 1)) # noqa: F821 -- native DSL intrinsic + + +@blosc2.menudet(cardinality="block_scalar") +def adjusted_min(x, y): + return block_min(x + (y - 1)) # noqa: F821 -- native DSL intrinsic + + +@blosc2.menudet(cardinality="block_scalar") +def adjusted_max(x, y): + return block_max(x + (y - 1)) # noqa: F821 -- native DSL intrinsic + + +@blosc2.menudet(cardinality="block_scalar") +def adjusted_any(x, y): + return block_any(x + (y - 1)) # noqa: F821 -- native DSL intrinsic + + +@blosc2.menudet(cardinality="block_scalar") +def adjusted_all(x, y): + return block_all(x + (y - 1)) # noqa: F821 -- native DSL intrinsic + + +def build_operands(size, kind, dtype="float64", cparams=None): + """Return the ``x``/``y`` operands and the expected result for one storage kind.""" + x = np.arange(size, dtype=dtype) + y = np.arange(1, size + 1, dtype=dtype) + expected = x + (y - 1) + if kind == "numpy": + return {"x": x, "y": y}, expected + layout = {} if size <= 1_000_000 else {"chunks": (1_000_000,), "blocks": (15625,)} + cparams = blosc2.CParams(codec=blosc2.Codec.ZSTD, clevel=5) if cparams is None else cparams + if size == 1: + # The DSL-backed Blosc2 constructor rejects scalar-like domains. + return { + name: blosc2.asarray(value, cparams=cparams) for name, value in {"x": x, "y": y}.items() + }, expected + inputs = { + "x": blosc2.arange(size, dtype=dtype, cparams=cparams, **layout), + "y": blosc2.arange(1, size + 1, dtype=dtype, cparams=cparams, **layout), + } + return inputs, expected + + +def make_engines(inputs, kind, reduc=None, cparams=None, selected=None): # noqa: C901 -- explicit engine routes + """Return an ordered mapping of engine name to a callable producing a result. + + LazyExpr returns compressed Blosc2 output; LazyExpr-NumPy, NumPy, numexpr + and evaluate always return NumPy. Menudet preserves the input storage kind. + """ + numpy_reduce = getattr(np, reduc) if reduc else None + numexpr_expression = f"{('sum' if reduc == 'mean' else reduc)}({EXPRESSION})" if reduc else EXPRESSION + if reduc in ("any", "all"): + # Numexpr has no any/all intrinsic; reduce exact floating 0/1 values. + # Float literals also avoid integer-extrema seed narrowing on NumPy 2. + operation = "max" if reduc == "any" else "min" + numexpr_expression = f"{operation}(where(({EXPRESSION}) != 0, 1.0, 0.0))" + + def finish_numpy(values): + return numpy_reduce(values) if reduc else values + + def finish_numexpr(resident): + result = ne.evaluate(numexpr_expression, local_dict=resident) + if reduc == "mean": + return result.item() / inputs["x"].size + if reduc in ("any", "all"): + return bool(result.item()) + return result.item() if reduc else result + + if kind == "numpy": + + def numpy_run(): + return finish_numpy(inputs["x"] + (inputs["y"] - 1)) + + def numexpr_run(): + return finish_numexpr(inputs) + + else: + + def numpy_run(): + x = inputs["x"][:] + y = inputs["y"][:] + return finish_numpy(x + (y - 1)) + + def numexpr_run(): + resident = {name: value[:] for name, value in inputs.items()} + return finish_numexpr(resident) + + if selected in ("NumPy", "numexpr", "evaluate"): + return { + selected: { + "NumPy": numpy_run, + "numexpr": numexpr_run, + "evaluate": lambda: blosc2.evaluate( + f"{reduc}({EXPRESSION})" if reduc else EXPRESSION, local_dict=inputs + ), + }[selected] + } + lazy = blosc2.lazyexpr(EXPRESSION, inputs) if selected in (None, "LazyExpr", "LazyExpr-NumPy") else None + if reduc: + author = { + "sum": adjusted_sum, + "mean": adjusted_mean, + "min": adjusted_min, + "max": adjusted_max, + "any": adjusted_any, + "all": adjusted_all, + }[reduc] + kernel = author.specialize(**inputs) if selected in (None, "Menudet") else None + + def menudet_reduce(): + resident = inputs if kind == "numpy" else {name: value[:] for name, value in inputs.items()} + return kernel.evaluate_block(resident).item() + + return { + "NumPy": numpy_run, + "numexpr": numexpr_run, + "LazyExpr-NumPy": getattr(lazy, reduc) if lazy is not None else None, + "LazyExpr": getattr(lazy, reduc) if lazy is not None else None, + "evaluate": lambda: blosc2.evaluate(f"{reduc}({EXPRESSION})", local_dict=inputs), + "Menudet": menudet_reduce, + } + menudet = adjusted(**inputs) if selected in (None, "Menudet") else None + output_options = { + "cparams": blosc2.CParams(codec=blosc2.Codec.ZSTD, clevel=5) if cparams is None else cparams + } + if kind == "blosc2": + first = inputs["x"] + output_options.update(chunks=first.chunks, blocks=first.blocks) + return { + "NumPy": numpy_run, + "numexpr": numexpr_run, + "LazyExpr-NumPy": lambda: lazy[:], + "LazyExpr": lambda: lazy.compute(**output_options), + "evaluate": lambda: blosc2.evaluate(EXPRESSION, local_dict=inputs), + "Menudet": (lambda: menudet.compute(**output_options)) if kind == "blosc2" else (lambda: menudet[:]), + } + + +def make_allocation_engines(inputs): + """Compare fresh/reused NumPy destinations without changing the main table. + + Reused cases share one buffer: benchmark calls are sequential and qualify + each result immediately. No operands are decompressed in this control. + """ + output = np.empty_like(inputs["x"]) + return { + "numexpr fresh": lambda: ne.evaluate(EXPRESSION, local_dict=inputs), + "numexpr reused": lambda: ne.evaluate(EXPRESSION, local_dict=inputs, out=output), + "evaluate fresh": lambda: blosc2.evaluate(EXPRESSION, local_dict=inputs), + "evaluate reused": lambda: blosc2.evaluate(EXPRESSION, local_dict=inputs, out=output), + } + + +@contextmanager +def cold_preparation(): + """Isolate expression/compiler caches, without flushing CPU or OS caches.""" + native = importlib.import_module("blosc2.native_graph") + lazy = importlib.import_module("blosc2.lazyexpr") + graph = importlib.import_module("blosc2.expression_graph") + native._native_plan_cache.clear() + for function in ( + native._native_first_syntax, + native._native_text_expression, + native.compile_plan, + native.resident_map_kernel, + lazy._evaluate_recipe_names, + graph.parse_expression, + graph.expression_syntax, + ): + function.cache_clear() + lazy._evaluate_recipe_cache.clear() + for author in ( + adjusted, + adjusted_sum, + adjusted_mean, + adjusted_min, + adjusted_max, + adjusted_any, + adjusted_all, + ): + author._kernels.clear() + for cache in (ne.necompiler._numexpr_cache, ne.necompiler._names_cache): + getattr(cache, "c", {}).clear() + keys = ("ME_DSL_JIT_CACHE_DIR", "ME_DSL_JIT_POS_CACHE") + previous = {key: os.environ.get(key) for key in keys} + with tempfile.TemporaryDirectory(prefix="menudet-cold-") as directory: + os.environ.update(ME_DSL_JIT_CACHE_DIR=directory, ME_DSL_JIT_POS_CACHE="0") + try: + with blosc2.jit_options(cache_dir=directory): + yield + finally: + for key, value in previous.items(): + if value is None: + os.environ.pop(key, None) + else: + os.environ[key] = value + + +def benchmark(engines, expected, samples, warmups, rng, failures=None, cold_factory=None): + """Correctness-check once, warm up, then time interleaved shuffled samples.""" + qualified = {} + for name, operation in engines.items(): + try: + result = operation() + if isinstance(result, blosc2.NDArray): + result = result[:] + if np.ndim(expected) == 0: + if np.ndim(result) != 0: + raise AssertionError("Reduction must return a scalar") + # Native/parallel summation can group floating additions differently. + np.testing.assert_allclose(result, expected, rtol=1e-12, atol=1e-12) + else: + np.testing.assert_array_equal(result, expected) + del result + except Exception as error: + if failures is None: + raise + message = str(error).strip().splitlines() + failures[name] = ( + "different numerical results" + if isinstance(error, AssertionError) + else f"{type(error).__name__}: {message[0] if message else 'unsupported execution'}" + ) + else: + qualified[name] = operation + engines = qualified + for _ in range(warmups): + for operation in engines.values(): + result = operation() + del result + times = {name: [] for name in engines} + for _ in range(samples): + order = list(engines) + rng.shuffle(order) + for name in order: + if cold_factory is not None: + with cold_preparation(): + start = perf_counter() + result = cold_factory(name)() + elapsed = (perf_counter() - start) * 1000 + else: + start = perf_counter() + result = engines[name]() + elapsed = (perf_counter() - start) * 1000 + times[name].append(elapsed) + del result + return {name: median(values) for name, values in times.items()} + + +def column_widths(items): + """Fix column widths up front so rows can be streamed while staying aligned.""" + item_width = max(len("items"), *(len(human_items(size)) for size in items)) + operand_width = len("operands") + engine_width = max(len(name) for name in ENGINES) + 1 + return item_width, operand_width, engine_width + + +def table_header(widths): + item_width, operand_width, engine_width = widths + cells = [ + "items".rjust(item_width), + "operands".ljust(operand_width), + *(name.rjust(engine_width) for name in ENGINES), + ] + return " ".join(cells) + + +def table_separator(widths): + item_width, operand_width, engine_width = widths + per_column = [item_width, operand_width, *([engine_width] * len(ENGINES))] + return " ".join("-" * width for width in per_column) + + +def result_row(row, widths, use_color): + """Format one (items, operands) row, highlighting its fastest engine.""" + item_width, operand_width, engine_width = widths + times = row["times"] + winner = min(times.values(), default=None) + cells = [human_items(row["items"]).rjust(item_width), row["operands"].ljust(operand_width)] + for name in ENGINES: + if name not in times: + cells.append("N/A".rjust(engine_width)) + continue + text = f"{times[name]:.3f}".rjust(engine_width) + if use_color and times[name] == winner: + text = f"{GREEN}{text}{RESET}" + cells.append(text) + return " ".join(cells) + + +def main(): # noqa: C901 -- CLI validation and warm/cold table orchestration + parser = argparse.ArgumentParser( + description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter + ) + parser.add_argument("--items", type=int, nargs="+", default=[100_000, 1_000_000, 8_000_000, 100_000_000]) + parser.add_argument( + "--samples", type=int, default=3, help="timed repetitions per row; the median is reported" + ) + parser.add_argument( + "--warmups", + type=int, + default=3, + help="untimed repetitions; 0 selects preparation-cold samples including compilation", + ) + parser.add_argument("--threads", type=int, default=12) + parser.add_argument( + "--dtype", + default="float64", + choices=( + "int8", + "uint8", + "int16", + "uint16", + "int32", + "uint32", + "int64", + "uint64", + "float32", + "float64", + ), + help="operand dtype (default: float64)", + ) + parser.add_argument( + "--codec", + type=str.lower, + choices=tuple(codec.name.lower() for codec in blosc2.Codec), + default="zstd", + help="codec for Blosc2 inputs and outputs (default: zstd)", + ) + parser.add_argument( + "--clevel", type=int, choices=range(10), default=5, help="compression level (default: 5)" + ) + parser.add_argument( + "--jit", + choices=("tcc", "cc"), + metavar="BACKEND", + help="miniexpr JIT compiler backend: tcc or cc (system compiler selected by CC)", + ) + parser.add_argument("--operands", choices=("both", "numpy", "blosc2"), default="both") + parser.add_argument( + "--allocation-control", + action="store_true", + help="also compare fresh/reused NumPy outputs for numexpr and evaluate (resident maps only)", + ) + parser.add_argument("--color", choices=("auto", "always", "never"), default="auto") + parser.add_argument( + "--reduc", + choices=("sum", "mean", "min", "max", "any", "all"), + help="reduce the expression to a scalar", + ) + args = parser.parse_args() + if args.samples <= 0 or args.warmups < 0 or any(size <= 0 for size in args.items): + parser.error("items and samples must be positive; warmups must be non-negative") + if args.threads <= 0: + parser.error("threads must be positive") + if args.allocation_control and (args.reduc or args.operands == "blosc2"): + parser.error("--allocation-control requires elementwise NumPy operand rows") + if args.allocation_control and args.warmups == 0: + parser.error("--allocation-control requires warm measurements (--warmups > 0)") + + # Select before LazyExpr preparation or Menudet dtype specialization. Both + # native compilation paths consume this environment override. + if args.jit is not None: + os.environ["ME_DSL_JIT_COMPILER"] = args.jit + # Enable JIT globally while leaving the Python backend override unset; + # native-first routes consume ME_DSL_JIT_COMPILER directly. + os.environ["BLOSC_ME_JIT"] = "true" + + use_color = args.color == "always" or (args.color == "auto" and sys.stdout.isatty()) + blosc2.set_nthreads(args.threads) + ne.set_num_threads(args.threads) + kinds = ("numpy", "blosc2") if args.operands == "both" else (args.operands,) + cparams = blosc2.CParams(codec=blosc2.Codec[args.codec.upper()], clevel=args.clevel) + + expression = f"{args.reduc}({EXPRESSION})" if args.reduc else EXPRESSION + print(f"Expression: {expression}") + mode = "Preparation-cold" if args.warmups == 0 else "Warm" + print(f"{mode} medians in milliseconds (lower is better); fastest figure per row in green.") + if args.warmups == 0: + print( + "Cold samples include engine preparation/compilation; inputs are prebuilt; CPU/OS caches are not flushed." + ) + print( + f"blosc2 {blosc2.__version__} | numpy {np.__version__} | numexpr {ne.__version__}" + f" | dtype {args.dtype} | threads {args.threads} | samples {args.samples}" + ) + print(f"Blosc2 compression: codec {args.codec} | clevel {args.clevel}") + print(f"Miniexpr JIT backend request: {os.environ.get('ME_DSL_JIT_COMPILER', 'runtime default')}") + print() + widths = column_widths(args.items) + print(table_header(widths)) + print(table_separator(widths), flush=True) + + rng = random.Random(42) + previous = None + allocation_rows = [] + for size in args.items: + for kind in kinds: + inputs, expected = build_operands(size, kind, args.dtype, cparams) + if args.reduc: + expected = getattr(np, args.reduc)(expected) + engines = make_engines(inputs, kind, args.reduc, cparams=cparams) + failures = {} + + def cold_factory(name, inputs=inputs, kind=kind): + return make_engines(inputs, kind, args.reduc, cparams=cparams, selected=name)[name] + + times = benchmark( + engines, + expected, + args.samples, + args.warmups, + rng, + failures=failures, + cold_factory=cold_factory if args.warmups == 0 else None, + ) + if args.allocation_control and kind == "numpy": + controls = make_allocation_engines(inputs) + control_times = benchmark(controls, expected, args.samples, args.warmups, rng, failures={}) + allocation_rows.append((size, tuple(controls), control_times)) + del controls + del inputs, engines, expected + if previous is not None and size != previous: + print(table_separator(widths)) + row = {"items": size, "operands": kind, "times": times} + print(result_row(row, widths, use_color), flush=True) + previous = size + + print() + if args.reduc: + print( + "Blosc2 operands: NumPy, numexpr and Menudet include operand decompression; " + "both LazyExpr columns and evaluate reduce directly." + ) + print( + "Menudet uses a native block reduction; numexpr mean uses sum/count. Reduction threading is engine-dependent." + ) + if args.reduc in ("any", "all"): + print("Numexpr any/all use 0/1 truth max/min; Menudet block truth reductions may short-circuit.") + else: + print( + "Blosc2 operands: NumPy and numexpr figures include operand decompression; " + "other engines evaluate directly over compressed inputs when eligible." + ) + print( + "NumPy, numexpr, LazyExpr-NumPy and evaluate return NumPy outputs. " + f"LazyExpr returns Blosc2 output ({args.codec}, clevel={args.clevel}); " + "Menudet does so for Blosc2 inputs only." + ) + if args.warmups: + print("evaluate caches eligible preparation; input rebinding and fresh output allocation are timed.") + else: + print( + "Each cold sample rebuilds its engine with empty preparation/compiler caches and fresh output." + ) + if allocation_rows: + print("\nAllocation control: resident inputs, NumPy outputs; warm medians in ms.") + print("Reused destinations are populated before timing; the main table above remains fresh-output.") + for size, names, times in allocation_rows: + figures = "; ".join( + f"{name} {times[name]:.3f}" if name in times else f"{name} N/A" for name in names + ) + print(f"{human_items(size)}: {figures}") + + +if __name__ == "__main__": + main() diff --git a/bench/menudet-integer-increment.py b/bench/menudet-integer-increment.py new file mode 100644 index 000000000..9f647add2 --- /dev/null +++ b/bench/menudet-integer-increment.py @@ -0,0 +1,74 @@ +"""Warm NumPy/Menudet/legacy DSL timings for x + 1 on resident arrays. + +Example: python bench/menudet-integer-increment.py --dtype int64 --compiler cc +Compilation and correctness checks are outside timings; every read allocates a +fresh NumPy result. Blosc2's thread count does not change NumPy's threading. +""" + +import argparse +import gc +import os +from statistics import median +from time import perf_counter + +import numpy as np + +import blosc2 + + +@blosc2.menudet +def portable(x): + return x + 1 + + +@blosc2.dsl_kernel +def legacy(x): + return x + 1 + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--items", type=int, default=100_000_000) + parser.add_argument("--dtype", choices=("int8", "int64", "float64"), default="int8") + parser.add_argument("--threads", type=int, nargs="+", default=[1, 2, 4, 8, 12]) + parser.add_argument("--repeat", type=int, default=5) + parser.add_argument("--compiler", choices=("tcc", "cc")) + args = parser.parse_args() + if args.items < 1 or args.repeat < 1 or min(args.threads) < 1: + parser.error("items, repeat and thread counts must be positive") + if args.compiler: + os.environ["ME_DSL_JIT_COMPILER"] = args.compiler + print(f"Package: {blosc2.__file__}\nExtension: {blosc2.blosc2_ext.__file__}") + x = np.arange(args.items, dtype=args.dtype) + expected = x + 1 + print(f"dtype={x.dtype}, items={x.size}, Menudet JIT={portable.specialize(x).has_jit}") + previous = blosc2.nthreads + try: + print(f"{'Threads':>7} {'NumPy ms':>12} {'Menudet ms':>12} {'Legacy ms':>12}") + for threads in args.threads: + blosc2.set_nthreads(threads) + modern = portable(x) + old = blosc2.lazyudf(legacy, (x,)) + engines = [lambda: x + 1, lambda expr=modern: expr[:], lambda expr=old: expr[:]] + for call in engines: + result = call() + assert result.dtype == x.dtype + np.testing.assert_array_equal(result, expected) + del result + samples = [[] for _ in engines] + for repeat in range(args.repeat): + for offset in range(len(engines)): + index = (repeat + offset) % len(engines) + gc.collect() + start = perf_counter() + result = engines[index]() + samples[index].append(perf_counter() - start) + del result + timings = " ".join(f"{median(values) * 1000:12.2f}" for values in samples) + print(f"{threads:7d} {timings}", flush=True) + finally: + blosc2.set_nthreads(previous) + + +if __name__ == "__main__": + main() diff --git a/bench/menudet-profile-parity.py b/bench/menudet-profile-parity.py new file mode 100644 index 000000000..b8060b452 --- /dev/null +++ b/bench/menudet-profile-parity.py @@ -0,0 +1,153 @@ +"""Application-layer paired timings; native numerical matrices live in miniexpr. + +Run with the intended editable/isolated package, e.g. --items 1000000 10000000. +Results are JSONL, flushed per configuration. Unsupported/mismatching legacy +controls are retained and excluded from timing rankings. No timing assertions. +""" + +import argparse +import gc +import json +import os +import platform +from pathlib import Path +from statistics import median +from time import perf_counter + +import numpy as np + +import blosc2 + +RECIPES = [ + ("add-i8", "int8", "x + y", "int8"), + ("add-i64", "int64", "x + y", "int64"), + ("add-f64", "float64", "x + y", "float64"), + ("literal-i8", "int8", "x + 1", "int8"), + ("literal-i64", "int64", "x + 1", "int64"), + ("deep-i64", "int64", "((x + y) * 2 - y) * 3 + x * 2 - y", "int64"), + ("compare-i64", "int64", "x < y", "bool"), + ("compare-f64", "float64", "x < y", "bool"), + ("trig-f64", "float64", "sin(x) + cos(x) + 1", "float64"), + ("minimum-f64", "float64", "minimum(x, y)", "float64"), + ("predicate-f64", "float64", "isfinite(x)", "bool"), + ("cast-i8-i64", "int8", "int64(x) + 1", "int64"), +] + + +def read_result(lazy, mode, selection, count): + if mode == "numpy": + return lazy[selection] + return lazy.compute(chunks=(min(262144, count),), blocks=(min(32768, count),), cparams={"clevel": 0}) + + +def main(): # noqa: C901 -- explicit serial benchmark matrix + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--items", type=int, nargs="+", default=[1_000_000, 10_000_000]) + parser.add_argument("--threads", type=int, nargs="+", default=[1, 12]) + parser.add_argument("--backends", nargs="+", choices=["tcc", "cc"], default=["tcc", "cc"]) + parser.add_argument("--layouts", nargs="+", default=["resident", "compressed", "strided", "broadcast", "partial", "step"]) + parser.add_argument("--names", nargs="+") + parser.add_argument("--repeat", type=int, default=3) + args = parser.parse_args() + if args.repeat < 3 or any(n < 1 for n in args.items + args.threads): + parser.error("positive sizes/threads and at least three repeats required") + if args.output.exists(): + parser.error("choose a new output file") + args.output.parent.mkdir(parents=True, exist_ok=True) + metadata = { + "package": blosc2.__file__, "extension": blosc2.blosc2_ext.__file__, + "platform": platform.platform(), "numpy": np.__version__, + "arguments": vars(args) | {"output": str(args.output)}, + } + args.output.with_suffix(".metadata.json").write_text(json.dumps(metadata, indent=2) + "\n") + previous = blosc2.nthreads + try: + with args.output.open("w") as stream: + for backend in args.backends: + os.environ["ME_DSL_JIT_COMPILER"] = backend + for name, dtype, expression, output in RECIPES: + if args.names and name not in args.names: + continue + source = f"def k(x, y):\n return {expression}\n" + author = blosc2.DSLKernel.from_source(source) + kernel = blosc2.PortableKernel.from_json(author.export({"x": dtype, "y": dtype}, output), jit=True) + for count in args.items: + x = (np.arange(count) % 3 + 1).astype(dtype) + y = (np.arange(count) % 2 + 1).astype(dtype) + compressed = None + for layout in args.layouts: + selection = slice(0, count // 10) if layout == "partial" else slice(None, None, 4) if layout == "step" else slice(None) + if layout == "compressed": + if compressed is None: + compressed = { + key: blosc2.asarray(value, chunks=(min(262144, count),), blocks=(min(32768, count),), + cparams={"clevel": 1}, dparams={"nthreads": 1}) + for key, value in {"x": x, "y": y}.items() + } + operands = compressed + resident = {"x": x, "y": y} + elif layout == "strided": + operands = resident = {"x": x[::-1], "y": y[::-1]} + elif layout == "broadcast": + operands = resident = {"x": x, "y": y[:1]} + else: + operands = resident = {"x": x, "y": y} + namespace = {"__builtins__": {}, "sin": np.sin, "cos": np.cos, + "minimum": np.minimum, "isfinite": np.isfinite, + "int64": lambda v: v.astype("int64"), **resident} + expected = eval(expression, namespace)[selection] + for threads in args.threads: + blosc2.set_nthreads(threads) + modern = kernel.lazy(operands) + old = blosc2.lazyudf(author, tuple(operands.values()), dtype=output, jit_backend=backend) + modes = ["numpy"] + if layout in ("resident", "compressed") and name in ("add-i8", "add-i64", "add-f64", "trig-f64"): + modes.append("blosc2") + for mode in modes: + row = {"name": name, "dtype": dtype, "output_dtype": output, "items": count, + "threads": threads, "backend": backend, "layout": layout, + "output": mode, "portable_jit": kernel.has_jit} + valid_engines = [] + row["status"] = "ok" + for label, lazy in (("portable", modern), ("legacy", old)): + try: + actual = read_result(lazy, mode, selection, count) + values = actual[:] if isinstance(actual, blosc2.NDArray) else actual + np.testing.assert_allclose(values, expected, rtol=2e-12, atol=2e-12) + assert values.dtype == np.dtype(output) + del actual, values + valid_engines.append((label, lazy)) + except Exception as error: + row["status"] = f"{label}_error" + row["error"] = f"{type(error).__name__}: {error}" + if valid_engines: + times = {"portable": [], "legacy": []} + for repeat in range(args.repeat): + engines = valid_engines.copy() + if repeat % 2: + engines.reverse() + for label, lazy in engines: + gc.collect() + start = perf_counter() + actual = read_result(lazy, mode, selection, count) + times[label].append(perf_counter() - start) + del actual + row["samples"] = times + for label, samples in times.items(): + if samples: + row[f"{label}_s"] = median(samples) + if all(times.values()): + row["ratio"] = row["portable_s"] / row["legacy_s"] + row["source_report"] = getattr(modern, "_source_execution_report", None) + stream.write(json.dumps(row) + "\n") + stream.flush() + print(row["name"], backend, count, layout, threads, mode, + row["status"], round(row.get("ratio", 0), 2), flush=True) + del compressed, x, y + finally: + blosc2.set_nthreads(previous) + + +if __name__ == "__main__": + main() diff --git a/bench/menudet-profile-reader.c b/bench/menudet-profile-reader.c new file mode 100644 index 000000000..fb32339bd --- /dev/null +++ b/bench/menudet-profile-reader.c @@ -0,0 +1,20 @@ +/* Profiling-only resident compressed-chunk decoder. Not a storage adapter: + * snapshots omit SChunk dictionary/postfilter/lazy-chunk integration. */ +#include + +void *menudet_profile_context(void) { + blosc2_dparams params = BLOSC2_DPARAMS_DEFAULTS; + params.nthreads = 1; + params.typesize = 8; + return blosc2_create_dctx(params); +} + +int menudet_profile_decode(void *context, const void *source, int source_bytes, + int start_bytes, int size_bytes, void *output) { + return blosc2_getitem_bytes_ctx(context, source, source_bytes, start_bytes, + size_bytes, output, size_bytes); +} + +void menudet_profile_free(void *context) { + blosc2_free_ctx(context); +} diff --git a/bench/ndarray/eye-comparison.py b/bench/ndarray/eye-comparison.py new file mode 100644 index 000000000..21a047fa5 --- /dev/null +++ b/bench/ndarray/eye-comparison.py @@ -0,0 +1,36 @@ +"""Compare eye's former chunkwise NumPy callback with portable execution.""" + +from statistics import median +from time import perf_counter + +import numpy as np + +import blosc2 + + +def legacy_eye(shape): + def fill(inputs, output, offset): + output[:] = np.eye(*output.shape, offset[0] - offset[1], dtype=output.dtype) + + return blosc2.lazyudf(fill, (0,), dtype=np.float64, shape=shape).compute() + + +for shape in ((100, 100), (1000, 1000), (4000, 4000), (10_000, 10_000)): + expected = np.eye(*shape) + for name, run in ( + ("numpy", lambda shape=shape: np.eye(*shape)), + ("previous", lambda shape=shape: legacy_eye(shape)), + ("menudet-interpreter", lambda shape=shape: blosc2.eye(*shape, jit=False)), + ("menudet-tcc", lambda shape=shape: blosc2.eye(*shape, jit=True, jit_backend="tcc")), + ("menudet-cc", lambda shape=shape: blosc2.eye(*shape, jit=True, jit_backend="cc")), + ): + result = run() + np.testing.assert_array_equal(result if name == "numpy" else result[:], expected) + del result + samples = [] + for _ in range(5): + begin = perf_counter() + result = run() + samples.append(1000 * (perf_counter() - begin)) + del result + print(shape, name, f"{median(samples):.3f} ms", flush=True) diff --git a/bench/ndarray/menudet-ramp.py b/bench/ndarray/menudet-ramp.py new file mode 100644 index 000000000..21e446313 --- /dev/null +++ b/bench/ndarray/menudet-ramp.py @@ -0,0 +1,56 @@ +"""Separate portable ramp setup from execution: conda run -n blosc2 python .""" + +import argparse +import importlib +from statistics import median +from time import perf_counter + +import numpy as np + +import blosc2 + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--repeats", type=int, default=5) + args = parser.parse_args() + ndarray = importlib.import_module("blosc2.ndarray") + print("Extension:", blosc2.blosc2_ext.__file__) + print("Threads:", blosc2.nthreads) + print("Setup includes export and load; evaluation excludes output allocation.") + for shape in ((8_000_000,), (2000, 4000), (200, 200, 200)): + for dtype in (np.dtype("int64"), np.dtype("float64")): + size = int(np.prod(shape)) + start = 0 if dtype.kind == "i" else 0.0 + step = 1 if dtype.kind == "i" else 1.0 / (size - 1) + expected = (np.arange(size) if dtype.kind == "i" else np.linspace(0, 1, size)).reshape(shape) + for backend in ("interpreter", "tcc", "cc"): + setup, evaluation = [], [] + for repetition in range(args.repeats + 1): + begin = perf_counter() + lazy = ndarray._menudet_ramp( + start, step, dtype, shape, + execution={"jit": backend != "interpreter", + "jit_backend": None if backend == "interpreter" else backend}, + ) + setup_time = perf_counter() - begin + output = blosc2.empty(shape, dtype=dtype) + begin = perf_counter() + try: + lazy.kernel._handle.evaluate_prefilter({}, out=output) + except blosc2.PortableArtifactError as error: + print(shape, dtype, backend, "FAILED:", error, flush=True) + break + evaluation_time = perf_counter() - begin + if repetition == 0: + np.testing.assert_allclose(output[:], expected) + else: + setup.append(setup_time * 1000) + evaluation.append(evaluation_time * 1000) + else: + print(shape, dtype, backend, "has_jit=", lazy.kernel.has_jit, + f"setup={median(setup):.3f} ms eval={median(evaluation):.3f} ms", flush=True) + + +if __name__ == "__main__": + main() diff --git a/bench/ndarray/native-graph-preparation.py b/bench/ndarray/native-graph-preparation.py new file mode 100644 index 000000000..5d9d2b6bf --- /dev/null +++ b/bench/ndarray/native-graph-preparation.py @@ -0,0 +1,93 @@ +"""Interleaved old export-twice/native JSON/native text preparation baseline. + +Run in fresh subprocesses for cold samples. Execution timings exclude storage IO; +graph/native iterator memory must not be labeled whole-process or compressed IO. +""" + +import argparse +import json +import platform +import statistics +import subprocess +import time + +import numpy as np + +import blosc2 +from blosc2.dsl_kernel import DSLKernel + + +def old_prepare(dtype): + author = DSLKernel.from_source("def k(x, y):\n return x * 2 + y\n") + signatures = {"x": dtype, "y": dtype} + first = author.export(signatures, "float64", version="1.1", casting="unsafe") + inferred = blosc2.PortableKernel.from_json(first).inferred_dtype + return blosc2.PortableKernel.from_json( + author.export(signatures, inferred, version="1.1", casting="unsafe") + ) + + +def timed(function): + start = time.perf_counter_ns() + result = function() + return result, (time.perf_counter_ns() - start) / 1000 + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--items", type=int, default=10000) + parser.add_argument("--repeats", type=int, default=20) + parser.add_argument("--dtype", choices=["float32", "float64", "int64"], default="float32") + args = parser.parse_args() + if args.items < 0 or args.repeats < 1: + parser.error("items must be nonnegative and repeats positive") + signature = {"x": args.dtype, "y": args.dtype} + seed = blosc2.NativeGraph.from_expression("x * 2 + y", signature).to_json() + timings = {"old_export_twice_us": [], "native_json_us": [], "native_text_us": []} + routes = { + "old_export_twice_us": lambda: old_prepare(args.dtype), + "native_json_us": lambda: blosc2.NativeGraph.from_json(seed), + "native_text_us": lambda: blosc2.NativeGraph.from_expression("x * 2 + y", signature), + } + for repeat in range(args.repeats): + names = list(routes) + names = names[repeat % 3 :] + names[: repeat % 3] + for name in names: + _, elapsed = timed(routes[name]) + timings[name].append(elapsed) + plan = blosc2.NativeGraph.from_json(seed) + metadata = {"x": (args.dtype, (args.items,)), "y": (args.dtype, ())} + schedule, specialize = timed(lambda: plan.specialize(metadata)) + values = {"x": np.arange(args.items, dtype=args.dtype), "y": np.array(3, dtype=args.dtype)} + (_, report), first = timed(lambda: schedule.execute(values)) + warm = [timed(lambda: schedule.execute(values))[1] for _ in range(args.repeats)] + values["y"] = np.array(4, dtype=args.dtype) + (result, _), rebind = timed(lambda: schedule.execute(values)) + np.testing.assert_array_equal(result, values["x"] * 2 + 4) + revision = subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip() + print( + json.dumps( + { + "python_revision": revision, + "python": platform.python_version(), + "numpy": np.__version__, + "platform": platform.platform(), + "items": args.items, + "dtype": args.dtype, + "repeats": args.repeats, + "backend": "portable-jit" if plan.has_jit else "portable-interpreter", + "preparation_median_us": {key: statistics.median(value) for key, value in timings.items()}, + "specialize_us": specialize, + "first_us": first, + "warm_median_us": statistics.median(warm), + "rebind_us": rebind, + "iterator": report, + "note": "Process imports warm; no result cache; no compressed reads; compiler memory/RSS not measured.", + }, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/bench/ndarray/native-graph-stages.py b/bench/ndarray/native-graph-stages.py new file mode 100644 index 000000000..7551b3803 --- /dev/null +++ b/bench/ndarray/native-graph-stages.py @@ -0,0 +1,102 @@ +"""Materialized stage costs; run repeatedly in fresh processes for cold samples. + +No compressed storage IO. RSS is process peak, not compiler-specific allocations. +""" + +import argparse +import json +import platform +import statistics +import subprocess +import time + +import numpy as np + +import blosc2 + + +def timed(function): + start = time.perf_counter_ns() + result = function() + return result, (time.perf_counter_ns() - start) / 1000 + + +def revision(path): + return subprocess.check_output(["git", "-C", path, "rev-parse", "HEAD"], text=True).strip() + + +def dirty(path): + return bool( + subprocess.check_output(["git", "-C", path, "diff", "HEAD", "--name-only"], text=True).strip() + ) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--rows", type=int, default=1000) + parser.add_argument("--columns", type=int, default=16) + parser.add_argument("--repeats", type=int, default=10) + parser.add_argument("--dtype", choices=["float32", "float64", "int64"], default="float32") + parser.add_argument("--jit", action="store_true") + args = parser.parse_args() + if args.rows < 1 or args.columns < 1 or args.repeats < 1: + parser.error("dimensions and repeats must be positive") + expression = "x - sum(x, axis=0)" + plan, preparation = timed( + lambda: blosc2.NativeGraph.from_expression(expression, {"x": args.dtype}, jit=args.jit) + ) + schedule, specialization = timed(lambda: plan.specialize({"x": (args.dtype, (args.rows, args.columns))})) + values = {"x": np.ones((args.rows, args.columns), dtype=args.dtype)} + (_, report), first = timed(lambda: schedule.execute(values)) + warm = [timed(lambda: schedule.execute(values))[1] for _ in range(args.repeats)] + values["x"].fill(2) + (result, _), rebind = timed(lambda: schedule.execute(values)) + np.testing.assert_array_equal(result, np.full(values["x"].shape, 2 - 2 * args.rows, dtype=result.dtype)) + try: + import resource + + rss = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss + rss *= 1 if platform.system() == "Darwin" else 1024 + except ImportError: + rss = None + print( + json.dumps( + { + "python_revision": revision("."), + "native_revision": revision("../miniexpr"), + "python_tracked_changes": dirty("."), + "native_tracked_changes": dirty("../miniexpr"), + "python": platform.python_version(), + "numpy": np.__version__, + "platform": platform.platform(), + "expression": expression, + "dtype": args.dtype, + "shape": values["x"].shape, + "jit_requested": args.jit, + "preparation_us": preparation, + "specialization_us": specialization, + "first_us": first, + "warm_median_us": statistics.median(warm), + "rebind_us": rebind, + "plan": { + key: value + for key, value in plan.info().items() + if key not in {"inputs", "inferred_dtype"} + }, + "schedule": {key: value for key, value in schedule.info().items() if key != "dtype"}, + "stages": [ + {**schedule.stage_info(i), "dtype": str(schedule.stage_info(i)["dtype"])} + for i in range(plan.info()["stages"]) + ], + "report": report, + "output_bytes": result.nbytes, + "process_peak_rss_bytes": rss, + "note": "Warm imports, first plan cold; metadata excludes compiler/artifact allocations; RSS includes all imports and NumPy reference checking.", + }, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/bench/ndarray/ramp-cold.py b/bench/ndarray/ramp-cold.py new file mode 100644 index 000000000..958017ad9 --- /dev/null +++ b/bench/ndarray/ramp-cold.py @@ -0,0 +1,77 @@ +"""First-call ramp latency in fresh processes with private empty JIT caches.""" + +import argparse +import importlib +import os +import subprocess +import sys +import tempfile +from pathlib import Path +from statistics import median +from time import perf_counter + + +def child(name, rank, route, mode, size): + import numpy as np + + import blosc2 + + nd = importlib.import_module("blosc2.ndarray") + shapes = { + 100_000: ((100_000,), (250, 400), (40, 50, 50)), + 100_000_000: ((100_000_000,), (10_000, 10_000), (400, 500, 500)), + } + shape = shapes[size][rank - 1] + execution = {"jit": mode != "interpreter"} + if mode in ("tcc", "cc"): + execution["jit_backend"] = mode + if route == "legacy_dsl": + nd._menudet_ramp_supported = lambda *unused: False + begin = perf_counter() + if route == "numpy": + output = (np.arange(size) if name == "arange" else np.linspace(0, 1, size)).reshape(shape) + elif route == "menudet": + dtype = np.dtype("int64" if name == "arange" else "float64") + start = 0 if name == "arange" else 0.0 + step = 1 if name == "arange" else 1.0 / (size - 1) + output = nd._compute_menudet_ramp(start, step, dtype, shape, execution, {}) + else: + output = (blosc2.arange(size, shape=shape, **execution) if name == "arange" + else blosc2.linspace(0, 1, size, shape=shape, **execution)) + elapsed = 1000 * (perf_counter() - begin) + expected = (np.arange(size) if name == "arange" else np.linspace(0, 1, size)).reshape(shape) + np.testing.assert_allclose(output if route == "numpy" else output[:], expected) + print(elapsed) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--repeats", type=int, default=5) + parser.add_argument("--size", type=int, choices=(100_000, 100_000_000), default=100_000) + parser.add_argument("--child", nargs=4) + args = parser.parse_args() + if args.child: + name, rank, route, mode = args.child + child(name, int(rank), route, mode, args.size) + return + for name in ("arange", "linspace"): + for route in ("numpy", "legacy_dsl", "menudet"): + for mode in (("native",) if route == "numpy" else ("interpreter", "tcc", "cc")): + times = [] + for rank in (1, 2, 3): + samples = [] + for _ in range(args.repeats): + with tempfile.TemporaryDirectory(prefix="ramp-cold-") as cache: + env = dict(os.environ, ME_DSL_JIT_CACHE_DIR=cache) + result = subprocess.run( + [sys.executable, str(Path(__file__).resolve()), "--size", str(args.size), "--child", + name, str(rank), route, mode], + env=env, capture_output=True, text=True, check=True, + ) + samples.append(float(result.stdout.strip().splitlines()[-1])) + times.append(round(median(samples), 3)) + print(name, route, mode, "1D/2D/3D ms:", times, flush=True) + + +if __name__ == "__main__": + main() diff --git a/bench/ndarray/ramp-comparison.py b/bench/ndarray/ramp-comparison.py new file mode 100644 index 000000000..caffc2f47 --- /dev/null +++ b/bench/ndarray/ramp-comparison.py @@ -0,0 +1,74 @@ +"""Compare eager NumPy, legacy DSL and portable ramp constructors.""" + +import argparse +import importlib +from statistics import median +from time import perf_counter + +import numpy as np + +import blosc2 + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--repeats", type=int, default=5) + parser.add_argument("--size", type=int, choices=(100_000, 8_000_000, 100_000_000), default=8_000_000) + args = parser.parse_args() + nd = importlib.import_module("blosc2.ndarray") + original_gate = nd._menudet_ramp_supported + print("Extension:", blosc2.blosc2_ext.__file__, flush=True) + print("Threads:", blosc2.nthreads, flush=True) + print("Times include kernel setup, allocation and storage; one warmup per case.", flush=True) + try: + shapes = { + 100_000: ((100_000,), (250, 400), (40, 50, 50)), + 8_000_000: ((8_000_000,), (2000, 4000), (200, 200, 200)), + 100_000_000: ((100_000_000,), (10_000, 10_000), (400, 500, 500)), + }[args.size] + for shape in shapes: + size = int(np.prod(shape)) + for name in ("arange", "linspace"): + expected = (np.arange(size) if name == "arange" else np.linspace(0, 1, size)).reshape(shape) + for route in ("numpy", "legacy_dsl", "menudet"): + modes = ("native",) if route == "numpy" else ("interpreter", "tcc", "cc") + for mode in modes: + execution = {"jit": mode != "interpreter"} + if mode in ("tcc", "cc"): + execution["jit_backend"] = mode + nd._menudet_ramp_supported = ( + (lambda *unused: False) if route == "legacy_dsl" else original_gate + ) + + def run(route=route, size=size, name=name, shape=shape, execution=execution): + if route == "numpy": + return (np.arange(size) if name == "arange" else np.linspace(0, 1, size)).reshape(shape) + if route == "menudet": + dtype = np.dtype("int64" if name == "arange" else "float64") + start = 0 if name == "arange" else 0.0 + step = 1 if name == "arange" else 1.0 / (size - 1) + return nd._compute_menudet_ramp(start, step, dtype, shape, execution, {}) + if name == "arange": + return blosc2.arange(size, shape=shape, **execution) + return blosc2.linspace(0, 1, size, shape=shape, **execution) + + output = run() + values = output if route == "numpy" else output[:] + if name == "arange": + np.testing.assert_array_equal(values, expected) + else: + np.testing.assert_allclose(values, expected) + del output, values + samples = [] + for _ in range(args.repeats): + begin = perf_counter() + output = run() + samples.append(1000 * (perf_counter() - begin)) + del output + print(name, shape, route, mode, f"{median(samples):.3f} ms", flush=True) + finally: + nd._menudet_ramp_supported = original_gate + + +if __name__ == "__main__": + main() diff --git a/bench/ndarray/safer_lazyexpr.py b/bench/ndarray/safer_lazyexpr.py new file mode 100644 index 000000000..3d1707ef4 --- /dev/null +++ b/bench/ndarray/safer_lazyexpr.py @@ -0,0 +1,231 @@ +"""Compare safe graphs with the trusted legacy evaluator in isolated processes. + +Use --baseline-root with an immutable source snapshot and the matching compiled +extension for a historical control. Otherwise full mode is only a legacy-path +proxy. No timing assertions run in CI. Outputs are checked before timing. +""" + +import argparse +import json +import math +import os +import platform +import statistics +import subprocess +import sys +import tempfile +import time +from pathlib import Path + + +def worker(args): + if args.package_root: + sys.meta_path = [ + finder for finder in sys.meta_path if type(finder).__module__ != "_editable_skbc_blosc2" + ] + sys.path.insert(0, args.package_root) + import cProfile + import resource + + import numpy as np + + import blosc2 + + if args.package_root: + assert Path(blosc2.__file__).resolve().is_relative_to(Path(args.package_root).resolve()) + + blosc2.set_nthreads(1) + n = args.size + shape = (max(1, n // 128), 128) if args.family == "axis" else (n,) + geometry = {} + if args.chunk_size: + if len(shape) != 1: + raise ValueError("--chunk-size currently requires one-dimensional workloads") + geometry = {"chunks": (min(n, args.chunk_size),), "blocks": (min(n, args.chunk_size, 256),)} + x = np.linspace(1, 4, math.prod(shape), dtype=args.dtype).reshape(shape) + y = np.ones_like(x) + expressions = { + "arithmetic": ("x * 2 + y", lambda: x * 2 + y), + "math": ("sqrt(x) + sin(x) + y", lambda: np.sqrt(x) + np.sin(x) + y), + "reduction": ("sum(sqrt(x))", lambda: np.sqrt(x).sum()), + "center": ("x - mean(x)", lambda: x - x.mean()), + "axis": ("x.mean(axis=0)", lambda: x.mean(axis=0)), + "index": ("x[::2] + y[::2]", lambda: x[::2] + y[::2]), + "open": ("sqrt(x) + y", lambda: np.sqrt(x) + y), + "partial": ("sqrt(x) + 1", lambda: np.sqrt(x[17:41]) + 1), + } + text, reference = expressions[args.family] + expected = reference() + item = slice(17, 41) if args.family == "partial" else () + with tempfile.TemporaryDirectory(dir=args.tempdir) as directory: + operands = { + "x": blosc2.asarray( + x, urlpath=str(Path(directory) / "x.b2nd") if args.family == "open" else None, **geometry + ), + "y": blosc2.asarray( + y, urlpath=str(Path(directory) / "y.b2nd") if args.family == "open" else None, **geometry + ), + } + timings = [] + construction = [] + first_execution = [] + open_times = [] + profiler = cProfile.Profile() if args.profile_output else None + for trial in range(args.repeats + 1): + start = time.perf_counter() + expr = ( + blosc2.lazyexpr(text, operands) + if args.package_root + else blosc2.lazyexpr(text, operands, evaluation=args.mode) + ) + constructed = time.perf_counter() - start + if args.family == "open": + path = str(Path(directory) / "expr.b2nd") + expr.save(path) + start = time.perf_counter() + expr = blosc2.open(path, deserialize=args.mode) + opened = time.perf_counter() - start + if trial: + open_times.append(opened) + start = time.perf_counter() + result = expr[item] + first = time.perf_counter() - start + np.testing.assert_allclose(result, expected, rtol=1e-5 if args.dtype == "float32" else 1e-12) + start = time.perf_counter() + if profiler is not None: + profiler.enable() + result = expr[item] + if profiler is not None: + profiler.disable() + elapsed = time.perf_counter() - start + if trial: + construction.append(constructed) + first_execution.append(first) + timings.append(elapsed) + if profiler is not None: + profiler.dump_stats(args.profile_output) + rss = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss + print( + json.dumps( + { + "family": args.family, + "mode": args.mode, + "size": n, + "dtype": args.dtype, + "construction_seconds": statistics.median(construction), + "first_execution_seconds": statistics.median(first_execution), + "repeated_execution_seconds": statistics.median(timings), + "execution_min_seconds": min(timings), + "execution_max_seconds": max(timings), + "open_seconds": statistics.median(open_times) if open_times else None, + "peak_rss_bytes": rss if sys.platform == "darwin" else rss * 1024, + "output_nbytes": np.asarray(result).nbytes, + "logical_input_nbytes": sum(value.nbytes for value in operands.values()), + "operand_chunks": {name: list(value.chunks) for name, value in operands.items()}, + "version": blosc2.__version__, + "platform": platform.platform(), + "package": blosc2.__file__, + "control": "historical source snapshot" if args.package_root else "current source", + } + ) + ) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--worker", action="store_true") + parser.add_argument("--mode", choices=["safe", "full"], default="safe") + parser.add_argument("--family", default="math") + parser.add_argument("--families", default="arithmetic,math,reduction,center,axis,index,open") + parser.add_argument("--size", type=int, default=100000) + parser.add_argument( + "--chunk-size", type=int, help="Fixed chunk extent for one-dimensional resource probes" + ) + parser.add_argument("--sizes", default="1000,100000,1000000") + parser.add_argument("--dtype", choices=["float32", "float64"], default="float64") + parser.add_argument("--repeats", type=int, default=5) + parser.add_argument( + "--rounds", + type=int, + default=1, + help="Independent process pairs; alternate execution order each round", + ) + parser.add_argument("--tempdir") + parser.add_argument("--package-root") + parser.add_argument("--baseline-root") + parser.add_argument("--output", type=Path) + parser.add_argument( + "--profile-output", + type=Path, + help="Worker only: profile repeated execution, excluding construction/open/checks", + ) + args = parser.parse_args() + if args.repeats < 1 or args.rounds < 1: + parser.error("--repeats and --rounds must be positive") + if args.chunk_size is not None and args.chunk_size < 1: + parser.error("--chunk-size must be positive") + if args.profile_output and not args.worker: + parser.error("--profile-output requires --worker") + if args.worker: + worker(args) + return + records = [] + env = dict(os.environ, NUMEXPR_NUM_THREADS="1", OMP_NUM_THREADS="1") + for round_number in range(args.rounds): + order = ("full", "safe") if round_number % 2 == 0 else ("safe", "full") + for size in map(int, args.sizes.split(",")): + for family in args.families.split(","): + pair = {} + for mode in order: + command = [ + sys.executable, + __file__, + "--worker", + "--mode", + mode, + "--family", + family, + "--size", + str(size), + "--dtype", + args.dtype, + "--repeats", + str(args.repeats), + ] + if args.tempdir: + command += ["--tempdir", args.tempdir] + if args.chunk_size: + command += ["--chunk-size", str(args.chunk_size)] + if mode == "full" and args.baseline_root: + command += ["--package-root", args.baseline_root] + completed = subprocess.run(command, env=env, check=True, text=True, capture_output=True) + record = json.loads(completed.stdout) + record["round"] = round_number + record["execution_order"] = list(order) + pair[mode] = record + records.extend((pair["full"], pair["safe"])) + ratios = [] + for full, safe in zip(records[::2], records[1::2], strict=True): + ratios.append( + { + "family": safe["family"], + "size": safe["size"], + "round": safe["round"], + "execution_ratio": safe["repeated_execution_seconds"] / full["repeated_execution_seconds"], + "construction_ratio": safe["construction_seconds"] / full["construction_seconds"], + } + ) + report = { + "records": records, + "ratios": ratios, + "geomean_execution_ratio": math.exp(statistics.mean(math.log(x["execution_ratio"]) for x in ratios)), + } + output = json.dumps(report, indent=2) + if args.output: + args.output.write_text(output + "\n") + else: + print(output) + + +if __name__ == "__main__": + main() diff --git a/doc/conf.py b/doc/conf.py index 915bb0c20..b709da445 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -111,7 +111,14 @@ def genbody(f, func_list, lib="blosc2"): ], } -exclude_patterns = ["_build", ".DS_Store", "**.ipynb_checkpoints", "tutorials/images/**"] +exclude_patterns = [ + "_build", + ".DS_Store", + "**.ipynb_checkpoints", + "tutorials/images/**", + "html/**", + "**/autofiles-stash/**", +] html_show_sourcelink = False @@ -306,7 +313,7 @@ def process_sig(app, what, name, obj, options, signature, return_annotation): # ``-W`` (as CI does) to turn that warning into a failure. _AUTODOC_DIRECTIVE = re.compile( - r"^\s*\.\.\s+(?:autoclass|autofunction|autodata|autoexception|autodecorator)::" + r"^\s*\.\.\s+(?:autoclass|autofunction|autodata|autoexception|autodecorator|py:class)::" r"\s*([\w.]+)" ) _CURRENTMODULE = re.compile(r"^\s*\.\.\s+(?:currentmodule|module)::\s*([\w.]+)") diff --git a/doc/getting_started/installation.rst b/doc/getting_started/installation.rst index fd0e689de..7ba918308 100644 --- a/doc/getting_started/installation.rst +++ b/doc/getting_started/installation.rst @@ -33,13 +33,13 @@ grouped into *extras* that you opt into with the ``blosc2[extra]`` syntax: - The :doc:`b2view <../guides/b2view>` terminal browser (``textual``, ``textual-plotext``), including its in-terminal braille plot (the ``p`` key). Required by the ``b2view`` command. - * - ``hires`` + * - ``hires`` - The high-resolution image view in b2view (the ``h`` key), which renders a real ``matplotlib`` image in the terminal - (``textual-image``, ``matplotlib``). Includes ``tui``. - * - ``images`` - - JPEG/PNG ordinary-file previews in b2view (``Pillow``, ``textual-image``). - Includes ``tui`` without requiring matplotlib. ``hires`` includes this extra. + (``textual-image``, ``matplotlib``). Includes ``tui``. + * - ``images`` + - JPEG/PNG ordinary-file previews in b2view (``Pillow``, ``textual-image``). + Includes ``tui`` without requiring matplotlib. ``hires`` includes this extra. * - ``parquet`` - The ``parquet-to-blosc2`` converter (``pyarrow``); see :doc:`../guides/parquet_to_blosc2`. diff --git a/doc/reference/additional_funcs.rst b/doc/reference/additional_funcs.rst index c5f79ceda..32412a84d 100644 --- a/doc/reference/additional_funcs.rst +++ b/doc/reference/additional_funcs.rst @@ -14,8 +14,10 @@ Their result is typically a :ref:`LazyExpr` instance, which can be evaluated (wi broadcast_to clip + complex contains endswith + fmod imag lower real @@ -28,8 +30,10 @@ Their result is typically a :ref:`LazyExpr` instance, which can be evaluated (wi .. autofunction:: blosc2.broadcast_to .. autofunction:: blosc2.clip +.. autofunction:: blosc2.complex .. autofunction:: blosc2.contains .. autofunction:: blosc2.endswith +.. autofunction:: blosc2.fmod .. autofunction:: blosc2.imag .. autofunction:: blosc2.lower .. autofunction:: blosc2.real diff --git a/doc/reference/ctable.rst b/doc/reference/ctable.rst index c1ec14ce5..81959123b 100644 --- a/doc/reference/ctable.rst +++ b/doc/reference/ctable.rst @@ -10,6 +10,18 @@ independently; rows are never materialised in their entirety unless you explicitly call :meth:`~blosc2.CTable.to_arrow` or iterate with :meth:`~blosc2.CTable.__iter__`. +.. note:: + + **Sharing a table between threads:** concurrent reads and writes to the + same underlying storage are unsupported. If a shared table can be modified + or closed, use one application lock around complete reads, writes, appends + and close operations. Views and column handles sharing that storage must + use the same lock. For lazy or computed columns, hold the lock while + evaluating the result, not just while creating the expression. + + Safe expression evaluation does not make table storage thread-safe or + provide a consistent snapshot across reads. + Source-bound columns -------------------- diff --git a/doc/reference/dsl_syntax.md b/doc/reference/dsl_syntax.md index 2568d3171..6a7dbd558 100644 --- a/doc/reference/dsl_syntax.md +++ b/doc/reference/dsl_syntax.md @@ -3,6 +3,10 @@ This is the practical reference for the DSL used by `@blosc2.dsl_kernel` functions (and checked by `blosc2.validate_dsl()`). It focuses on what works today and the most common gotchas. +The portable subset is named **Menudet**, a little language for portable +computation on arrays and tables. See the [Menudet reference](portable_dsl.rst) +for the Menudet 1.0 draft contract and numerical rules. This page also documents ordinary full-DSL features; +acceptance here does not imply portability. For usage walkthroughs and end-to-end examples, see the [LazyArray UDF DSL kernels tutorial](../tutorials/03.lazyarray-udf-kernels.ipynb). @@ -18,6 +22,139 @@ def kernel(x, y): Use Python-style indentation and always return a value on the paths you execute. +### Native source without a Python function + +`blosc2.DSLKernel.from_source(source)` constructs a native-only kernel without +executing source as Python or inspecting Python globals: + +```python +source = """# me:compiler=tcc +def affine(x): + return x * 2.0 + 1.0 +""" +kernel = blosc2.DSLKernel.from_source(source) +result = blosc2.lazyudf(kernel, (x,), dtype="float64")[:] +``` + +The source and header pragmas are preserved verbatim. Input dtypes come from the +supplied arrays; pass an explicit output dtype. The native compiler validates the +body with these types during computation. The constructor inspects only the +plain positional function header and does not certify Menudet support. +Frontend conveniences, captured globals, and Python-function fallback are not +available on this path; use native function spellings such as `sin(x)`. + +This is separate from the existing Python-based persistence reconstruction path. +Menudet artifact export/import is still under development. The full native +language reference and experimental Menudet profile live in miniexpr's +`doc/dsl-syntax.md` and `doc/dsl-spec/1.0.md`, respectively. The Menudet profile +and artifact contract are experimental drafts; see [Menudet artifacts](portable_dsl.rst) +for the release boundary and legacy Python persistence policy. + +### Experimental Menudet validation + +```python +info = blosc2.validate_portable_dsl(source, {"x": "float64"}, "float64") +if not info["valid"]: + print(info["status"], info["line"], info["column"], info["error"]) +``` + +This native-only check uses raw source and explicit logical dtypes, with no +frontend rewriting or captured globals. It neither executes the kernel nor +invokes a JIT compiler. It reports version, signature, source, and unsupported +feature errors separately. Potential runtime errors, including missing returns +on some paths, do not automatically invalidate a program. + +Menudet 1.0 admits Boolean, standard integer widths, float32/float64 and fixed strings, +NumPy-style numeric typing/arithmetic, block reductions and explicit ND context. +It is separate from the ordinary full language described below. +Validation is not a sandbox, backend-support probe, or a guarantee about +arbitrary runtime data. Older native builds report `runtime_unsupported` rather +than attempting Python validation. Native dependency integration for this +experimental API is pending; development builds can use the local miniexpr source +via CMake's `FETCHCONTENT_SOURCE_DIR_MINIEXPR` override. + +### Menudet artifact export and import (experimental) + +Export with explicit input/output dtypes. Scalar globals and closure values are +snapshotted into typed manifest constants, not inserted as Python literals: + +```python +SCALE = 2.0 + + +@blosc2.dsl_kernel +def scaled(x): + return x * SCALE + + +artifact = scaled.export({"x": "float64"}, "float64") +SCALE = 99.0 # Does not change the saved artifact. +kernel = blosc2.PortableKernel.from_json(artifact, jit=False) +values = kernel.evaluate({"x": np.arange(4, dtype=np.float64)}) +# values: array([0., 2., 4., 6.]) +``` + +`export()` returns deterministic UTF-8 JSON text; save it with an ordinary file +write. `from_json()` accepts text or bytes, not a pathname or decoded mapping. +Import uses the same native JSON loader as C and does not need the author's module, +function, decorators, globals, Python source reconstruction, or frontend rewrites. +`evaluate()` returns a new NumPy array; `blosc2.asarray(values)` can materialize +compressed storage. `kernel.lazy()` binds explicit logical partitions for lazy +evaluation and portable persistence. Newly authored compliant DSLKernel-backed +LazyUDF saves also normalize and validate portable native recipes automatically. + +Python `bool`, `int`, and `float` captures infer `bool`, `int64`, and `float64`. +Supported NumPy scalar types retain their dtype. Use +`capture_dtypes={"SCALE": "float32"}` to explicitly specialize a capture; finite +float narrowing and explicit integer-to-float conversion round to the chosen dtype; +out-of-range values reject. Arrays (including zero-dimensional arrays), objects, unsupported +scalar types, unresolved names, and external callbacks cannot be captures. +Export does not call the kernel or capture conversion hooks. It reuses supported +authoring normalization, such as `np.sin(x)`, before native profile validation. +Fixed byte/Unicode scalar snapshots are supported; arbitrary objects and callbacks are not. + +Native-only kernels can bind existing parameters as constants explicitly: + +```python +author = blosc2.DSLKernel.from_source( + "# me:compiler=cc\ndef scaled(x, scale):\n return x * scale\n" +) +artifact = author.export({"x": "float64"}, "float64", constants={"scale": 2.0}) +``` + +Every source parameter requires exactly one runtime input or constant binding. +Parameters and captures may have different supported dtypes; computation is +operand-driven before output conversion. Manifest float constants preserve +IEEE bit patterns, including signed zero and non-finite values; integer constants +are range-checked decimal strings. Comments and retained native pragmas survive +parameterization. Required strict FP semantics are independent of host defaults; +compiler pragmas remain preferences. Draft 1.0 currently always uses the typed interpreter. + +Runtime arrays are bound by name in any mapping order and must have the exact +declared logical dtype and common shape. The adapter converts endian order, +alignment, and strides, but does not broadcast arrays or silently change their +dtype. Constant-only kernels require `evaluate({}, shape=(...))`; empty +elementwise arrays validate bindings without execution, whereas scalar reductions +obey their specified empty identities/errors. `PortableArtifactError` provides `status`, `native_status`, `line`, and +`column` for malformed artifacts, unsupported requirements, source, binding, and +evaluation failures. The artifact format is not a sandbox or an arbitrary-input +numerical-correctness guarantee. + +Native dependency packaging is still pending. For development builds, use both +`FETCHCONTENT_SOURCE_DIR_MINIEXPR` and `MINIEXPR_BUILD_ARTIFACT=ON`, for example: + +```sh +conda run -n blosc2 python -m pip install -e . --no-build-isolation --no-deps \ + --config-settings=cmake.define.FETCHCONTENT_SOURCE_DIR_MINIEXPR=/path/to/miniexpr \ + --config-settings=cmake.define.MINIEXPR_BUILD_ARTIFACT=ON +``` + +The optional adapter links pinned yyjson only when enabled. Builds without the +adapter remain usable and report `NotImplementedError` for artifact operations, +without attempting Python validation/execution as a fallback. The native candidate +format and shared fixtures live in miniexpr's `doc/dsl-spec/artifact-1.0.md` and +`tests/portable-artifacts/`. + `@blosc2.jit` auto-detects this DSL: a decorated function whose body contains an `if`/`for`/`while` and that compiles under this grammar is dispatched here automatically, so its branches and loops actually run, once per chunk, instead @@ -43,12 +180,30 @@ Supported file-header pragmas: - `# me:fp=strict|contract|fast` - `# me:compiler=tcc|cc` +- `# me:math=auto|system|sleef|accelerate` +- `# me:ulp=u10|u35` Notes: - Pragma keys must be unique. - Unknown `me:*` pragmas are errors. - Malformed pragma values are errors. +- `auto` and `system` both select system math; `auto` is the default and does + not consult `ME_SIMD_MATH_BACKEND`. Explicit `sleef`/`accelerate` requests fail + during preparation when unavailable. +- `me:ulp` is valid only with SLEEF; omitted accuracy is `u35`. +- `contract` and `fast` require the `cc` backend (TCC supports strict only). +- An explicit pragma overrides the matching environment setting + (`ME_DSL_FP_MODE`, `ME_SIMD_MATH_BACKEND`) for that prepared kernel. + +```python +# me:compiler=cc +# me:fp=fast +# me:math=sleef +# me:ulp=u35 +def kernel(x): + return sin(x) + cos(x) +``` ## Function signature and inputs diff --git a/doc/reference/index.rst b/doc/reference/index.rst index a0ba44c75..6fc2636c6 100644 --- a/doc/reference/index.rst +++ b/doc/reference/index.rst @@ -12,4 +12,6 @@ API Reference save_load utilities dsl_syntax + portable_dsl + menudet_accuracy jit diff --git a/doc/reference/jit.rst b/doc/reference/jit.rst index ecae2de28..5de7a4b10 100644 --- a/doc/reference/jit.rst +++ b/doc/reference/jit.rst @@ -145,10 +145,30 @@ accept them through ``**kwargs``. Eligible lazy-expression reductions, such as settings tune execution rather than array storage; they are not options to :func:`blosc2.empty`. +Automatic policy uses miniexpr's validated structural classification: a single +``return `` defaults to interpretation, while programs with multiple +statements, assignments, branches or loops prefer JIT. Physical source line count +does not determine the classification. Explicit ``jit`` settings and source +compiler pragmas retain priority. The policy is selected before compilation. +This is a conservative structural heuristic, not a profitability guarantee; +explicit overrides remain useful for unusual or repeatedly executed workloads. + +This applies consistently to eligible string expressions, graph-generated maps +and Menudet artifacts. ``evaluate()`` does not accept per-call JIT keywords; +use ``blosc2.jit_options(jit=True)`` or ``blosc2.set_jit_options(jit=True)`` to opt +in. Native metadata is exposed as ``PortableKernel.execution_kind``. Older native +runtimes report ``"unknown"`` and retain their existing native default behavior. + +Scalar miniexpr reductions currently use the native interpreter, even when JIT +is requested. Elementwise DSL returns (including automatically lifted expressions) +write a block of values and cannot safely target a single reduction accumulator. +Other execution options still apply, and non-scalar reduction paths retain their +usual evaluation policies. + ``jit=None`` (default) - Use the entry point's default policy. DSL kernels, including the real-valued - ramps used by ``arange`` and ``linspace``, try JIT. Plain expressions do not - automatically become DSL kernels unless JIT is requested. Ordinary Python + Select automatic structural policy: interpret single-return expressions and + prefer JIT for multi-statement programs. An explicit source compiler pragma + requests compilation even for a single-return expression. Ordinary Python callback UDFs are not compiled by TCC/CC through this option. ``jit=True`` @@ -160,6 +180,11 @@ settings tune execution rather than array storage; they are not options to described below. Depending on the expression, the non-JIT route can be the miniexpr interpreter or another existing compute engine. + Native interpretation can use bounded vector arithmetic primitives already + compiled into miniexpr. This does not generate or compile code at runtime. + Unsupported or checked recipes retain scalar interpretation, preserving + their validation, masking and error behavior. + ``jit_backend=None`` (default) Use the default backend: TCC on supported native targets. Under WebAssembly/Pyodide, eligible floating-point DSL kernels prefer the JavaScript @@ -268,9 +293,17 @@ controls have different scopes; neither is an indication that JIT actually ran. - Disable applicable process-local positive-cache reuse. This does not disable persistent CC disk-cache reuse. * - ``ME_DSL_JIT_COMPILER`` - - Advanced miniexpr-wide compiler override, ``tcc`` or ``cc``. It overrides - native compiler selection in DSL pragmas, including the selection emitted - by Python's ``jit_backend`` option. Prefer per-call options ordinarily. + - Advanced miniexpr-wide compiler default, ``tcc`` or ``cc``. It overrides + Python's ``jit_backend`` selection, but an explicit author-written + ``# me:compiler=tcc|cc`` pragma remains authoritative. + * - ``ME_SIMD_MATH_BACKEND`` + - Default math library, ``auto|system|sleef|accelerate|scalar``. ``auto`` + and ``system`` select system math; ``scalar`` forces system scalar math. + Explicit ``sleef``/``accelerate`` requests fail when unavailable. + * - ``ME_DSL_FP_MODE`` + - Default floating-point mode, ``strict|contract|fast`` (``relaxed`` is an + alias of ``fast``). An explicit ``# me:fp=...`` pragma remains + authoritative. ``contract``/``fast`` require the ``cc`` backend. Tracing and restricted environments ----------------------------------- diff --git a/doc/reference/lazyarray.rst b/doc/reference/lazyarray.rst index bd6368a71..09ef5b18f 100644 --- a/doc/reference/lazyarray.rst +++ b/doc/reference/lazyarray.rst @@ -54,6 +54,23 @@ An expression like ``a + sum(b)``, where there is at least one NDArray object in This object follows the `LazyArray`_ API for computation and storage. +For eligible elementwise expressions over matching in-memory, one-dimensional +Blosc2 operands, execution follows the requested output storage: + +* ``expr.compute()`` writes directly to Blosc2 chunks through the native + prefilter. Matching explicit ``chunks``/``blocks`` and a matching Blosc2 + ``out`` buffer remain eligible. Compression and storage options are honored; + use ``cparams=blosc2.CParams(clevel=0)`` for uncompressed output. +* ``expr[:]`` returns NumPy values. Above the automatic parallel-map crossover, + workers decompress and evaluate bounded tiles directly into the final NumPy + allocation. Matching writable, contiguous NumPy ``out`` buffers can use this + path too. + +Blosc2-output requests with partial selections, incompatible grids, mixed storage +or unsupported numerical contracts retain their existing fallbacks. An execution +failure on an admitted native route is raised, rather than replayed through +another engine. + .. autofunction:: lazyexpr .. _LazyUDF: diff --git a/doc/reference/menudet_accuracy.md b/doc/reference/menudet_accuracy.md new file mode 100644 index 000000000..9c890b31f --- /dev/null +++ b/doc/reference/menudet_accuracy.md @@ -0,0 +1,52 @@ +# Menudet draft: numeric certification + +Menudet 1.0 requires its specified wrapping/checked integer results and the stated floating-point type, +domain, NaN, infinity, signed-zero and rounding rules. It does **not** promise +bit-identical transcendental results across host math libraries or a universal +ULP error bound. Native exact-anchor and exceptional-value tests remain separate +from the bounded independent math check described here. + +## Reproducible independent references + +`scripts/menudet_math_vectors.json` contains 284 samples for 40 canonical +operations, covering both float32 and float64. Inputs and expected results are +stored as exact hexadecimal encodings. References were generated with mpmath +1.3.0 at both 100 and 200 decimal digits; regeneration rejects disagreement +between the two rounded results. The checker does not need mpmath and does not +use NumPy or the executing host's libm as its mathematical reference. + +The finite domains include inverse-function endpoints, small arguments that +exercise cancellation, mixed quadrants, gamma functions, and explicit fused +multiply-add cancellation. Domain errors, NaNs/infinities, subnormal behavior, +signed zeros, rounding functions, nextafter and aliases additionally have native +conformance fixtures; they are not certified merely by these finite samples. + +| Operations | Maximum error for the checked samples | +| --- | --- | +| cospi, sinpi, exp10, lgamma, tgamma, logaddexp | 8 ULP | +| Other sampled transcendental functions, sqrt, hypot, floating pow | 4 ULP | +| fdim, fmin, fmax, copysign, fmod, remainder, ldexp, fma | Exact rounded value | + +These are **function-specific acceptance budgets for this finite corpus**, not +new normative bounds over all possible inputs. ULP is measured using the smaller +adjacent gap at the expected value, including at powers of two. Adding a new +sample or changing a budget requires review; a failed platform must not silently +skip a function or inflate its tolerance. + +## Running certification + +Against an installed package: + +```console +python scripts/certify_menudet_math.py --report menudet-math.json +``` + +Reports identify the package path/version, platform, reference generator, sample +count, per-function/per-precision maxima and individual failures. The process +exits nonzero on failure. Use `--generate` only to regenerate the checked-in +reference corpus in a development environment with mpmath installed. + +Native Python CI uploads the reports. The same corpus runs in Pyodide and in the +installed-wheel test command, without adding a runtime reference-library +dependency. Passing a local wheel certifies only that tested wheel and host; +release readiness additionally requires the supported platform matrix to pass. diff --git a/doc/reference/misc.rst b/doc/reference/misc.rst index e9ce82962..e91d413bf 100644 --- a/doc/reference/misc.rst +++ b/doc/reference/misc.rst @@ -7,7 +7,10 @@ This page documents the miscellaneous members of the ``blosc2`` module that do n .. autodata:: cpu_info -.. autoclass:: finfo +.. py:class:: finfo(dtype) + + Return floating-point limits for ``dtype``. This is an alias for + :class:`numpy.finfo`; see NumPy's reference for its attributes and examples. .. autoclass:: iinfo diff --git a/doc/reference/portable_dsl.rst b/doc/reference/portable_dsl.rst new file mode 100644 index 000000000..94573a96c --- /dev/null +++ b/doc/reference/portable_dsl.rst @@ -0,0 +1,827 @@ +Menudet: portable computation +============================= + +**Menudet — a little language for portable computation on arrays and tables.** + +Menudet is the language; miniexpr is its native implementation, and Python-Blosc2 +provides authoring, array scheduling and table integration. The existing +``DSLKernel``, ``PortableKernel`` and ``validate_portable_dsl`` API names remain +unchanged. Python-like authoring syntax normalizes to a language-independent +artifact; a Menudet artifact is not an executable Python recipe. + +.. warning:: + + Menudet 1.0 is experimental. Its language and artifact specifications are + drafts, not a frozen compatibility promise. Native cross-platform CI passes; + independent numeric accuracy and Python release-wheel certification are + tracked separately. Beta feedback will inform the final compatibility contract. + +Menudet 1.0 is the single public language and artifact version. It uses +NumPy-style numerical rules; the interpreter defines behavior, and eligible +kernels may use JIT. The legacy/full DSL is a separate semantic profile. +Earlier unreleased checked-arithmetic and 1.1 drafts are development predecessors, +not supported public versions. Re-export their artifacts with the current runtime. + +The names ``PortableKernel``, ``PortableArtifactError``, ``validate_portable_dsl`` +and the JSON language identifier ``"miniexpr"`` remain unchanged implementation +and API identifiers. They do not name another language. + +Artifacts are standalone UTF-8 JSON, executable through native miniexpr in C or +Python, without reconstructing or executing Python functions on import. + +Source-authored execution +------------------------- + +Supported ``lazyudf(DSLKernel, ...)`` calls now execute through Menudet, including +the control-flow route of ``@blosc2.jit``. The ``LazyUDF`` API and storage options +remain unchanged; kernels are exported without calling their Python bodies. +Evaluation-time JIT settings still override construction-time settings. + +Scalar-return broadcasting and padded chunk-local block groups retain their +original LazyUDF membership, even when slicing or rechunking output. Native +compiler/cache/trace settings are scoped to artifact loading without changing +environment variables. Strict portable JIT accepts optimization-level flags; +other compiler flags conservatively select interpretation. + +Compatibility execution remains for trusted legacy recipes, unsupported dtypes, +the explicit JS backend, and custom compiler/cache/trace settings on older native +runtimes without the artifact-options API. WebAssembly uses portable Menudet +interpretation; its JIT selection is pinned off. Native ``@blosc2.jit`` +control-flow wrappers require Menudet and reject unsupported cases rather than +silently using legacy DSL. These are explicit dispatch gates; +portable compilation errors do not silently retry legacy execution. + +Eligible C-order ``arange()`` and ``linspace()`` calls use Menudet at every size. +Unless explicitly overridden, fewer than 4 million elements use interpretation +to avoid compilation latency; larger ramps try JIT. Unsupported constructor +dtypes/options and non-C-order traversal retain compatibility execution. + +Complex support +--------------- + +Menudet supports ``complex64`` and ``complex128`` on macOS, Linux and WASM32. +Complex kernels execute in the typed interpreter; complex JIT is not implemented, +so a JIT request still uses interpretation. Windows rejects complex inputs, +constants and intermediates explicitly and continues to execute real kernels. + +Complex storage is two interleaved components of the declared float width. +Artifact constants use one ``ieee754-hex`` string: the big-endian real component +followed by the big-endian imaginary component, each 8 hex digits for complex64 +and 16 for complex128. Source ``j`` literals are not part of the grammar; bind +complex values as constants instead. + +Declared operation set: + +- Arithmetic ``+ - * / **``, unary negation, truth tests and ``where``. +- ``abs``/``fabs``, ``real``, ``imag``, ``conj``, ``sign``, ``square`` and ``rint``. +- ``sqrt``, ``exp``, ``exp2``, ``expm1``, ``log``, ``log1p``, ``log2``, ``log10``, + trigonometric/hyperbolic and inverse functions. +- ``block_sum``, ``block_prod``, ``block_mean``, ``block_min``, ``block_max``, + ``block_any`` and ``block_all``. +- Component-wise ``==``/``!=``; ``< <= > >=`` use NumPy's lexicographic + (real, imag) ordering with NaN unordered. + +Rejected explicitly: floor division, remainder, bitwise/shift operations, +``ceil``/``floor``/``trunc``, ``logaddexp``, ``signbit``, and explicit complex to +real/integer casts. Output casting may discard the imaginary component only under +an ``unsafe`` artifact policy. Mixed promotion follows NumPy: 16-bit integers and +bool fit complex64, wider integers promote the result to complex128. + +Menudet 1.0 numerical semantics +------------------------------ + +Export defaults to ``version="1.0"``. Numeric manifests declare +``numeric="numpy-2.5"`` and a final output casting policy (``unsafe`` by default, +or ``same_kind``/``safe``). Source literals and ordinary Python captures are weak +scalars; NumPy scalars and explicit capture dtypes are strong typed scalars. +Array integer arithmetic wraps at its computation width; weak scalar construction +and integer block reduction accumulation retain their checked rules. +Floating-to-integer conversion rejects nonfinite/out-of-range values. + +Inverse functions use canonical Array API/C names: ``asin``, ``acos``, ``atan``, +``atan2``, ``asinh``, ``acosh`` and ``atanh``. Python authoring accepts NumPy's +``arc*`` spellings and normalizes calls before native compilation/export. Native +source and raw saved artifacts containing these removed aliases reject in both +profiles; update the source or re-export from authoring. Artifact import does not +silently migrate saved source. + +.. code-block:: python + + import blosc2 + import numpy as np + + author = blosc2.DSLKernel.from_source("def increment(x):\n return x + 1\n") + artifact = author.export({"x": "int8"}, "int64", version="1.0", casting="safe") + kernel = blosc2.PortableKernel.from_json(artifact) + kernel.inferred_dtype # dtype('int8'), before final int64 conversion + kernel.evaluate({"x": np.array([127, -128, 0], dtype="int8")}) + # array([-128, -127, 1], dtype=int64): arithmetic wraps at int8, not int64 + +Menudet 1.0 implements fixed-width wrapping arithmetic, NumPy strong dtype +promotion, Boolean arithmetic restrictions, floor division/remainder, bitwise +operators and shifts. Weak source literals and plain Python numeric captures +preserve NumPy 2.x scalar strength; NumPy scalar captures and explicit +``capture_dtypes`` are strong. Typed runtime inputs, including 0-D arrays, +remain strong. Scalar categories and numerical policy are stored in the artifact. + +Fixed-width casts such as ``int8(x)`` and ``float32(x)`` are Menudet 1.0 syntax. +Final output conversion declares ``casting="safe"``, ``"same_kind"`` or +``"unsafe"``; inference and policy validation inspect metadata, not input values. +Weak scalar construction is checked; unsafe array integer narrowing wraps. +Floating-to-integer conversion truncates but deliberately rejects nonfinite or +out-of-range values instead of codifying NumPy's platform-dependent sentinels. +Function signatures and exceptional values are covered by the native M4 matrix. +``minimum``/``maximum`` propagate NaNs while ``fmin``/``fmax`` select a non-NaN +operand. Signed-zero ties follow deterministic IEEE minimum/maximum rules; +NumPy's tie bits can vary between loops. ``where`` evaluates only selected lanes, +unlike eager NumPy argument evaluation. Float16-result signatures reject explicitly. + +Menudet 1.0 also provides per-call IEEE floating status: + +.. code-block:: python + + inputs = {"x": np.array([127, 0], dtype="int8")} + values, status = kernel.evaluate(inputs, return_status=True) + # status = {"flags": integer_bits, "supported": bool} + values = kernel.evaluate(inputs, fp_errors="raise") + +Bits are invalid=1, divide-by-zero=2, overflow=4 and underflow=8. Each call clears +its status; standalone block users explicitly OR status across blocks or threads. +Only evaluated active operations participate, and native calls restore the caller's +rounding mode and flags. ``fp_errors="ignore"`` is default; ``"raise"`` attaches +``.fp_status`` to ``PortableArtifactError``. No NumPy warning/callback emulation +is promised. On WASM, status reports ``supported=False`` and raising is unsupported; +zero flags there do not imply exception-free computation. + +Decorated Menudet functions +-------------------------- + +``@blosc2.menudet`` wraps ordinary function source as a portable native kernel. +Calling it binds inputs and returns a lazy array; the original Python function +is never executed, even when JIT is unavailable or native execution fails. + +.. code-block:: python + + @blosc2.menudet + def adjusted(x, y): + return x + (y - 1) + + + values = adjusted(x, y)[:] + result = adjusted(x, y).compute() # Materialized NDArray. + kernel = adjusted.specialize(x, y) # PortableKernel; no array evaluation. + artifact = kernel.to_json() + +Unannotated NumPy/Blosc2 arrays supply their element dtypes at call time. +Numeric result dtypes are inferred by native compilation before final output +conversion, not by executing Python or inspecting input values. The numeric +inference probe uses a temporary float64 output signature but never evaluates +that artifact. If native inference is unavailable, specify a return annotation. +Nonnumeric kernels require an explicit return dtype annotation. + +.. code-block:: python + + @blosc2.menudet(jit=True) + def adjusted(x: np.float64, y: np.float64) -> np.float64: + return x + (y - 1) + +Annotations describe element dtypes, not shapes. Annotated inputs must match +exactly; there are no implicit input casts. Scalar arguments require annotations. +Positional/keyword calls and Python defaults are bound without executing the +function. Scalar globals/closures are snapshotted at decoration; unsupported +captures reject. Specializations are cached by dtype signature, independently of +array shapes and values. Logical broadcasting follows ``PortableKernel.lazy``. + +JIT is preferred by default. ``jit=False`` selects native interpretation; +``require_jit=True`` rejects a specialization without compiled JIT. Unsupported +JIT lowering can use the native interpreter, but numerical failures are never +replayed. Unlike automatic LazyExpr dispatch, Menudet remains native even when +interpretation is slower. ``partitions``, ``cardinality``, ``ndim`` and ``casting`` +are decorator options for explicit portable block/context contracts. Default +partitions cover the whole logical domain; eligible compressed inputs use native +storage dispatch as described below. + +Eligible ordinary libm calls bind dtype-specific scalar callbacks during native +JIT preparation, avoiding per-element operation-name dispatch. This does not +enable fast-math or substitute vector math libraries. Operations with special +Menudet numerical rules retain their semantic bridges. + +Existing ``@blosc2.dsl_kernel`` authoring/export and legacy UDF calling conventions +are unchanged. See ``examples/menudet_decorator.py`` and ``bench/menudet-engines.py``. + +Parallel resident reads +~~~~~~~~~~~~~~~~~~~~~~~ + +Full lazy reads of large resident NumPy arrays can run the prepared portable +artifact concurrently. Eligibility requires matching shapes, aligned +C-contiguous host-endian inputs, and a proven lane-local elementwise +recipe. Floating inputs support the existing arithmetic/math subset. Same-dtype +integer inputs additionally support modular addition, subtraction, multiplication, +bitwise AND/OR/XOR, unary signs and inversion, with representable integer literals. +Every arithmetic subtree must involve an array; checked constant-only expressions, +mixed integer dtypes, shifts, division and integer casts remain on the original route. +Broadcasting, partial reads, reductions, context, scalar captures, +constant-only weak arithmetic and final dtype conversions retain their original +execution. Inputs are not copied or automatically normalized for this route. + +The scheduler uses at most ``blosc2.nthreads`` workers (capped at 32), with at +least 128K values per worker on average; fewer than two workers keeps serial +execution. Set ``blosc2.set_nthreads(1)`` to retain serial resident reads. +Reusable threads invoke the native evaluator without the GIL and write disjoint +regions of one private output allocation. All workers finish before publication +or error propagation. Floating flags are aggregated, execution errors are never +replayed, and standalone ``kernel.evaluate_block(...)`` remains a single logical +invocation. Callers must not mutate inputs during a read. + +On macOS, native graph schedules use the system's synchronous dispatch executor, +avoiding Python task submission for these resident maps. Other platforms retain +the Python host executor. Both routes join all tasks before returning. + +Eligible single-stage portable-JIT ``LazyExpr`` graphs use this scheduler too. +Their prepared native map artifact is borrowed with its owner retained, rather +than recompiled. Immutable weak scalar captures are substituted only in the +metadata safety proof; evaluation continues to use the original captured values +and artifact. Typed captures, staged/reduction graphs, partial selections, +broadcast or strided inputs, and nondefault ``_native_tile_items`` overrides keep +the original graph executor. Automatic backend eligibility is otherwise unchanged. + +Compressed storage dispatch +~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +When the native runtime provides storage readers, eligible elementwise Menudet +calls support bounded compressed input reads, including basic integer/slice +indexing and broadcasting. NumPy buffers remain resident. Automatic dispatch +also accelerates full reads of matching, resident 1-D floating-point arrays: + +* A single chunk with at most 32 MiB of total physical input capacity is decoded + once into NumPy buffers and evaluated by the portable kernel. +* Matching multi-chunk inputs (or single chunks over that budget) use a native + C-Blosc2 prefilter. Compression workers decode input blocks and call the same + prepared portable Menudet evaluator, not the legacy DSL evaluator. +* Partial selections, mismatched layouts, broadcasting, persisted inputs, + dictionary inputs, postfilters, and unsupported dense layouts retain bounded + storage readers. No automatic whole-array rechunking is performed. + +The prefilter route caps input block staging at 32 MiB by limiting worker count, +and requires its output scheduling chunk buffer to fit within another 32 MiB. +These are not total-memory limits: codec/evaluator scratch, compressed output +storage and the final NumPy result are additional. Result memory is proportional +to the requested output in every route. Eligibility checks precede input reads; +execution failures propagate without selecting another route. + +Explicit reader execution and scratch diagnostics are available through +``kernel.evaluate_sources(inputs, tile_items=65536, return_report=True)``. +This explicit API always uses readers/resident buffers, independently of automatic +single-chunk or prefilter selection. +The report's ``temporary_bytes`` covers native iterator scratch, not the result, +Python tile metadata, or codec internals. ``maximum_reader_items`` records the +largest reader request. Reader execution is not necessarily faster than existing +chunked LazyExpr execution: small spans can repeatedly decompress boundary blocks. + +This initial route excludes block reductions, locals/loops, coordinate-dependent +kernels, checked weak integer intermediates, and final dtype conversions. Scalar +captures and out-of-range weak floating constants also prevent proving lane-local +conversion safety. These lazy calls retain their original partition execution. +Proxies and table columns +also retain existing execution. Explicit reader requests reject unsupported +kernels/runtimes before reading; numerical or storage errors never replay through +another backend. + +Logical arrays and native-required graphs +---------------------------------------- + +The experimental native array ABI adds logical broadcasting and axis reductions +without changing explicit block-reduction recipes: + +.. code-block:: python + + # A numeric, elementwise Menudet 1.0 kernel, with rank-zero logical context: + values, report = kernel.evaluate_array(inputs, return_report=True) + totals = kernel.evaluate_array(inputs, reduction="sum", axis=-1, keepdims=True) + +Inputs may be C/F-order, transposed, negative-stride, unaligned or byte-swapped +views, and singleton/0-D inputs broadcast to the logical domain. Output owns +C-order storage. Native iterator scratch is bounded by ``tile_items`` and reported +separately from cumulative gathers and host normalization copies. In-place/aliased +output is unsupported. Scalar initial values and broadcast Boolean participating +masks are supported by the six reductions: sum/prod/min/max/any/all. + +Reduction grouping is serial logical C order, independent of iterator tiles and +storage chunks; floating sums need not match NumPy's pairwise bits. Narrow integer +accumulators wrap modularly. Floating-to-integer accumulator overrides, cumulative +and arg reductions, general gathers/scatters and mutable views are unsupported. + +Integer sum/product reductions default to fixed 64-bit accumulators: ``int64`` +for Boolean and signed integer inputs, and ``uint64`` for unsigned inputs. +This preserves artifact semantics across platforms and matches NumPy's defaults +on 64-bit hosts, but not its platform-dependent defaults on 32-bit hosts such as +WASM32. On those hosts, result dtypes and overflow behavior can differ from NumPy. + +Ordinary ``LazyExpr.compute()`` and ``expr[:]`` now try a conservative native-first +subset: whole-domain, nonempty NumPy arrays of native-endian bool, integer or +float32/float64 dtype, with real numeric scalar captures. Addition, subtraction, +multiplication, unary signs/inversion, bitwise operators and single comparisons +are eligible, including broadcasting, when native JIT preparation succeeds. +Automatic execution requests JIT by default; ``jit=False`` and unavailable JIT +retain existing execution rather than using the slower native graph interpreter. +The six reduction methods (``sum/prod/min/max/any/all``) and root reduction +expressions over eligible arithmetic also select native graphs, including axes, +``keepdims``, accumulator dtypes and ``initial``. General calls, division/powers, +partial indexing, proxy/table operands, output aliases and execution overrides +retain existing execution. Compressed inputs can automatically select streamed +whole-domain floating sum/min/max reductions over same-shaped 1-D inputs with +matching compressed chunks/blocks, no mask or ``initial``, and at least two workers. +Whole-domain ``any/all`` use the same streamed path with Boolean, integer or +float32/float64 inputs, including Boolean comparison expressions. +Reduction selection requires at least 16 million items and blocks of at most 65,536 items to amortize +reader overhead; smaller or unsupported cases retain legacy execution. NumPy +operands can be mixed with these compressed inputs. Whole-domain NumPy-output +elementwise reads (``expr[:]`` and ``blosc2.evaluate(...)`` without ``out=``) +also select streamed graphs with Boolean, integer or float32/float64 inputs. +For all-float64 inputs with at least eight configured threads, their size floor +is 2 million items; other elementwise cases keep the 16-million-item floor. +The layout/block limits are unchanged. Small-array benchmarks did not justify +using streamed graphs at 1 million items or below. Workers process disjoint, +physical-block-aligned contiguous regions, including regions within one chunk, +of one fresh NumPy allocation, retaining private decoder contexts and bounded +input scratch for their whole region. Ordinary tiles match one physical block; +tiny blocks are grouped to amortize dispatch. The reader decodes block by block +to avoid the decoder's multi-block input-copy path. Immutable region schedules are cached without +retaining input or output arrays. There is no full intermediate result, +output copy or prefilter zero-fill. Compressed-result ``compute()`` and explicit +output buffers retain their existing routes. ``evaluation="safe"`` remains a +syntax policy, not a backend selector. + +Automatic selection prepares/validates the graph before execution; unsupported +preparation can retain existing execution, but execution errors never trigger +replay. ``_require_native=False`` explicitly retains existing execution. + +For the shared basic grammar, array-only arithmetic/comparison expressions and +supported root reduction calls with literal arguments are ingested directly by +miniexpr's native text frontend. Python retains syntax/operand safety checks but +does not construct graph nodes or serialize declarative JSON for this subset. +Plans are cached by normalized expression, input dtypes and JIT configuration, +never by input values. External scalar captures, method-style reductions, +explicit reduction-method options, dtype syntax requiring normalization and +staged expressions retain the declarative Python adapter. Execution reports +identify the selected ``frontend`` as ``native-expression`` or ``declarative-json``. +This changes preparation only; execution thresholds and storage scheduling are +unchanged. + +``blosc2.evaluate()`` also keeps up to 128 operand-free construction recipes for +array-only basic arithmetic/comparison expressions without ``out=`` or extra +options. Recipe identity includes the expression, input dtypes/shapes, storage +kind, compressed layout and evaluation policy. Every invocation owns a fresh +LazyExpr, binds current inputs and rechecks execution eligibility; array values, +operand ownership, output buffers and execution reports are never cached. +Scalar captures, aliased input names, reductions and more complex syntax retain +ordinary construction. Warm ``evaluate`` benchmark timings include input +rebinding and fresh output allocation, but avoid repeated metadata inference. + +Large whole-domain floating sum/min/max reductions over aligned, contiguous, +same-shaped NumPy operands can run in parallel using ``blosc2.nthreads``. Each +worker reduces its region serially, then partial results are combined in region +order. ``any/all`` also run in parallel for same-shaped, contiguous Boolean, +integer or float32/float64 NumPy inputs. They evaluate all regions rather than +short-circuiting on a decisive partial result, preserving later execution errors +and aggregated floating status. Partial Booleans are combined with native OR/AND; +there is no rounding-order difference for the truth reduction itself. +Floating sums change addition grouping: small differences from serial or +NumPy reductions are expected, and cancellation can amplify them. Results can depend on the thread +count. Parallel extrema preserve the serial native graph's first-NaN payload +selection and signed-zero policy (min favors negative zero, max positive zero). +This policy need not match NumPy's bitwise zero selection. Other graph reductions, +reductions with ``initial``, broadcasting, strided inputs or only some axes reduced +retain serial native accumulation for now. +Use ``expr.sum(_require_native=False)`` to retain legacy reduction execution +(which is not necessarily serial). Use +``expr.sum(_require_native=True, jit=True)`` for serial native graph accumulation. +Explicit ``NativeGraph`` execution likewise retains its serial-order contract. +Automatically streamed compressed reductions use the same partial-result policy. +Their native readers own independent decompression contexts and cache only the current +compressed chunk; decoded scratch is bounded by worker count and tile size, not +the full operand size. They do not materialize complete operands. + +.. code-block:: python + + x = np.arange(6, dtype=np.float64) + y = np.ones(6, dtype=np.float64) + expr = blosc2.lazyexpr("x + (y - 1)", {"x": x, "y": y}) + values = expr[:] # Native JIT when available; otherwise existing execution. + result = expr.compute() # Same selection, returning an NDArray. + total = expr.sum() # Native graph; large eligible floating sums use parallel workers. + +An explicit experimental graph execution mode supports a broader subset and +rejects rather than falling back: + +.. code-block:: python + + expr = blosc2.lazyexpr("x * 2 + 1", {"x": array}) + result = expr.compute(_require_native=True) + accelerated = expr.compute(_require_native=True, jit=True) + totals = expr.sum(axis=0, _require_native=True) + artifact = expr.native_kernel().to_json() + +Eligible arithmetic/functions fuse into an immutable native graph plan. Python +adapts syntax, explicit captures and storage owners; miniexpr owns numerical +validation, type inference, broadcasting, reduction planning and execution. +Python does not generate DSL/export twice or plan broadcasting on this route. +Plans cache signatures/captures, never +operand results. NumExpr is not a runtime or installation dependency. Native +interpretation remains available without JIT; unsupported operations use explicit +NumPy fallbacks. Explicit backend/accuracy policies retain existing dispatch +in automatic mode. In strict native-required mode, nested lazy/proxy/table +operands, row filtering/ordering, output aliases, reduction partial reads and +acceleration overrides reject. Basic elementwise slicing is supported. + +Single-region native-required reductions stream compressed operands, including +axes, broadcasting and mixed storage, without full input materialization. +``NativeGraph.evaluate_sources()`` exposes this bounded reader route explicitly: + +.. code-block:: python + + compressed = blosc2.asarray(np.arange(1000, dtype=np.float64)) + plan = blosc2.NativeGraph.from_expression("sum(x + 1)", {"x": "float64"}, jit=True) + total, report = plan.evaluate_sources( + {"x": compressed}, tile_items=65536, return_report=True + ) + assert report["input_materialization_bytes"] == 0 + +Native traversal validates bindings before storage reads; reader or numerical +failures never trigger legacy replay. Staged reader graphs and compressed reduction +masks are not supported. Native iterator scratch is not an end-to-end memory bound: +decoder/chunk caches, output storage and resident-buffer normalization are separate. +Other explicit compressed graph execution (such as elementwise reads) can still +materialize inputs, reported separately. Exported elementwise Menudet artifacts can use existing safe +portable persistence; logical reduction descriptors are not persisted as though +they were block-scalar recipes. + +Native declarative preparation +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Graph-enabled miniexpr builds additionally expose ``blosc2.NativeGraph``. This +experimental format (``menudet-graph-1``) is separate from artifact versions and +portable recipe persistence. Preparation never requires numerical input buffers: + +.. code-block:: python + + plan = blosc2.NativeGraph.from_expression( + "where(x != 0, y / x, y)", {"x": "float32", "y": "float32"} + ) + schedule = plan.specialize({"x": ("float32", (3,)), "y": ("float32", ())}) + metadata = schedule.info() # Native map/output shapes and result dtype. + values, report = schedule.execute( + { + "x": np.array([0, 2, 4], dtype="float32"), + "y": np.array(8, dtype="float32"), + } + ) + imported = blosc2.NativeGraph.from_json(plan.to_json()) + +The restricted native text grammar is not general Python. Declarative JSON stores +explicit weak/typed categories, lossless scalar encodings and optional root +sum/prod/min/max/any/all options. Native final conversion is distinct from map +precision/reduction accumulation and has an explicit intermediate memory budget. +Input shapes/dtypes must match the schedule; re-specialize changed shapes, not +changed values. Schedules retain their immutable plans and permit independent +concurrent invocations. Actual JIT selection is reported by ``plan.has_jit``. + +Intermediate reductions and shared array computations use the separately declared +materialized staged subset. Native text and Python adapters declare the staged +capability when they contain intermediate reductions; miniexpr alone determines +the stage boundaries and inferred dependency types. For example: + +.. code-block:: python + + plan = blosc2.NativeGraph.from_expression("x - sum(x, axis=0)", {"x": "float32"}) + schedule = plan.specialize({"x": ("float32", (3, 4))}, intermediate_budget=16) + stage = schedule.stage_info(0) # Output shape/dtype/bytes and last consumer. + +All intermediate buffers are budgeted/preallocated before any stage executes and +released after their last consumer. Reports separate iterator scratch, reserved +intermediate bytes and actual interpreted/JIT stage counts. Explicit staged JSON +may also compose trusted, validated Menudet 1.0 elementwise/context-free regions +with an ordered-lazy, unmasked contract; arbitrary full-DSL recipes still reject. +Implicit conditional/masked staging, scalar-only weak stage sharing, computed +participation masks, callbacks, storage IO and partial staged reads remain excluded. +Older native +dependencies reject graph preparation explicitly, without retaining a duplicate +Python planner. For exact-pair local builds, pass +``-Ccmake.define.FETCHCONTENT_SOURCE_DIR_MINIEXPR=/path/to/miniexpr`` to pip. + +An explicit ``PortableKernel.from_json(artifact, jit=True)`` request can accelerate +the supported Menudet 1.0 subset with TCC or the system C compiler: numeric elementwise +expressions, exact integral comparisons, lazy ``where`` and Boolean expressions, +locals, conditional returns, logical ND context, and lane-local ``for``/``while`` +loops with nested ``break``/``continue`` and returns. Range conversion and while +limits retain their checked semantics. Strong typed integer arithmetic remains +modular; weak integer arithmetic remains checked. + +Checked numeric casts and numeric builtins, including integer-preserving math, +combinatorial functions, ``ldexp`` and ``fma``, use exact-bit scalar bridges where +direct lowering is unavailable. These bridges execute individual operations on +already computed operands, not entire expression subtrees. Computed weak operands +and floating captures can use runtime checks; validated immutable integer/Boolean +capture leaves retain their value-specialized fast path. + +A block-scalar recipe containing numeric ``block_sum`` or ``block_prod``, +numeric ``block_mean``, or numeric ``block_min``, ``block_max``, ``block_any`` +or ``block_all`` can also compile. Multiple reductions use independent serial +scans in expression order, rather than fusing across checked or lazy operands. +Uniform scalar ``if``/``elif``/``else`` branches and early returns are supported; +only selected branches scan their reductions. Eligible mapped operands, +scalar local assignments and surrounding arithmetic are supported, for example +``return block_sum(x * 2) / 2`` or ``s = block_mean(x); return s + 1``. +The reduction loop executes at its expression position, including inside lazy +branches, and fuses the map with serial accumulation. Per-operation rounding, +participating masks and original logical partitions are preserved. Empty sums +and products retain their identities; empty means return NaN without introducing +a divide-by-zero exception. Outside reduction maps, input reads must be uniform +captures rather than array lanes. +Extrema preserve NaN and signed-zero semantics and reject empty participating +groups. Truth reductions retain their empty-group identities and evaluate every +participating mapped operand, even after the Boolean result is determined, so +later checked errors and floating diagnostics are not silently skipped. +Integer sums/products use the fixed 64-bit accumulator widths described above +and retain checked accumulator overflow, even when strong arithmetic in their +mapped operands is modular. Plain input reductions use the optimized native +reducer; mapped operands use a fused scan with authoritative accumulator steps. +Empty or fully masked groups with statement conditionals are routed to the +interpreter before execution, preserving its empty-group control-flow rules. + +Floating and unsigned ``range`` arguments use checked implicit ``int64`` +conversion. Floating bounds truncate toward zero; nonfinite/out-of-range bounds +and a zero converted step raise the same error with or without JIT. Explicit +strong integer casts remain modular. Definite assignment at conditional joins +considers only paths that continue past the join; potentially empty loops still +cannot establish a new local for a later read. +This is not parallel reduction or streaming of staged graph intermediates. +Check ``kernel.has_jit`` to distinguish compiled execution from fallback. Select +the backend before importing the artifact with ``ME_DSL_JIT_COMPILER=tcc`` or +``ME_DSL_JIT_COMPILER=cc``; ``CC`` selects the latter compiler (e.g. GCC). + +Participating masks and floating diagnostics retain Menudet semantics. Integral +comparisons never pass through floating-point transport; floating comparisons use +a host bridge for NaN exception behavior. Ordered temporaries and immediate error +checks prevent failed operands from evaluating later operands. Local stores retain +assignment precision and diagnostics even if their values are unused. + +Integer mean uses a checked int64/uint64 accumulator followed by float64 +conversion and division, matching interpretation (including overflow and empty +group NaNs). Scalar recipes support ``for``/``while`` post-processing with +``break``, ``continue`` and early returns. The while-iteration cap is read per +invocation. Top-level array-valued locals are materialized in statement order +and can be reused by subsequent maps and reductions; their buffers are released +on every return/error. Branch/loop-local array assignments retain interpretation +until per-lane initialization tracking is supported. Empty/fully masked scalar +groups with statement control flow choose interpretation before execution. +Reductions inside varying statement branches or loop bodies remain rejected. Unsupported +definite-assignment patterns, fixed strings, and backend limitations also fall back. +Portable WASM JIT is not enabled: the legacy WASM source adapter does not preserve +the exact 64-bit typed-bridge ABI. Passing WASM interpretation tests is not JIT +qualification. +Arbitrary ``CFLAGS``/TCC option overrides make this subset ineligible rather +than weakening strict floating semantics. No explicit SIMD qualification is claimed. +Default backend selection remains unchanged; profile and scalar +categories survive export/import and lazy recipe persistence. + +Qualification ownership +~~~~~~~~~~~~~~~~~~~~~~~ + +Exhaustive lowering, dtype-boundary, checked-error and backend numerical parity +belongs to miniexpr. Its ordinary native CI runs full TCC coverage and compact +GCC/Clang regression gates. Weekly runs and explicit manual runs with +``full_qualification=true`` execute the full system-compiler matrix and sanitizer +checks before publishing exact-revision qualification evidence. + +Python CI retains production-binding integration checks: artifact round trips, +capture/dtype binding, exception/status translation, masks, logical context, +original partitions, graph/lazy execution and independent wheel imports. It uses +TCC for these checks plus a small supported-system-compiler smoke test; it does +not rerun miniexpr's complete native test matrix. The original Python numerical +reference tests remain available explicitly with ``pytest --native-semantics``. + +The final paired workflow requires a full native commit SHA and successful full +native qualification for that exact revision. A lightweight native gate, a +skipped full-qualification job or another revision's evidence is not sufficient. +Release qualification should use this exact-pair workflow; ordinary development +tests do not claim release qualification. This split does not change release +dependency pins or supported-platform fallback behavior. + +Default authoring example +------------------------ + +.. code-block:: python + + import blosc2 + import numpy as np + + author = blosc2.DSLKernel.from_source("def affine(x):\n return x * 2.0 - 1.0\n") + artifact = author.export({"x": "float64"}, "float64") + kernel = blosc2.PortableKernel.from_json(artifact, jit=False) + values = kernel.evaluate({"x": np.arange(4, dtype="float64")}) + # array([-1., 1., 3., 5.]) + +The result is an eager NumPy array. Bindings are named and require exact dtypes +and matching shapes. Supported dtypes are Boolean, standard signed/unsigned +integer widths, ``float32``, ``float64`` and fixed-width bytes/Unicode strings; +parameters may have different dtypes. Captured Python/NumPy scalars are snapshotted into +typed constants, never live callbacks or arrays. Integers use range-checked +decimal strings; floats use exact IEEE-754 hexadecimal bits. + +For a runnable array/table example using the same kernel, see +``examples/menudet.py`` in the source distribution. Numeric certification and its +finite-domain limits are described in :doc:`menudet_accuracy`. + +Release boundary +---------------- + +Menudet 1.0 reductions are named ``block_sum``, ``block_prod``, +``block_min``, ``block_max``, ``block_mean``, ``block_any`` and ``block_all``. Each takes one +operand and reduces only the supplied evaluation block's valid, participating +lanes. There is no ``axis`` or ``keepdims`` argument and no automatic combination +of results across blocks. Changing evaluation partitions can change results. +Bare reduction calls, including ``mean``, are rejected; existing draft artifacts +must be updated or re-exported. General lazy expressions and native array/graph +plans retain whole-array and axis reductions with their existing names. + +``block_mean`` divides the ordered sum by the number of participating lanes. +Float32/float64 inputs retain their dtype; integer/Boolean inputs use a checked +integer sum and return float64. Integer accumulation overflow raises an error. +An empty or entirely masked block returns NaN. + +``DSLKernel.export`` and ``validate_portable_dsl`` default to draft 1.0. +Native validation of normalized source, typed captures, +fixed widths and cardinality completes before export returns JSON:: + + author = blosc2.DSLKernel.from_source("def total(x):\n return block_sum(x)\n") + record = author.export({"x": "int64"}, "int64", + cardinality="block_scalar") + kernel = blosc2.PortableKernel.from_json(record) + values = kernel.lazy({"x": np.arange(6, dtype="int64")}, partitions=(3,))[:] + # array([3, 12]) + +Menudet 1.0 admits all standard Boolean/integer widths, float32/float64, fixed byte +and Unicode strings, NumPy-style numeric promotion and arithmetic, +native math/string operations, masked ordered block reductions and logical ND +coordinates. Specify ``ndim`` for coordinate-bearing sources. Existing static +``row["column"]``, NumPy calls and string syntax reuse the full-DSL authoring +normalizers; dynamic indexing, objects and callbacks are not reconstructed. + +Raw draft source can also be checked without artifacts, arrays, execution or JIT:: + + info = blosc2.validate_portable_dsl( + "def coordinate(x):\n return x + _i0\n", + {"x": "int16"}, "int64", ndim=1, + cardinality="elementwise") + assert info["valid"] + +The core native validator checks exact numeric/string signatures and reports +native status and source line/column. String dtypes specify exact slot widths, +for example ``{"x": "U4"}``; output widths must match native inference. +``cardinality=None`` checks inferred cardinality; an explicit declaration must +match. Reserved ND symbols require an explicit covering ``ndim``. This source +validator remains available when the optional artifact JSON loader is disabled. +It checks raw native syntax, not Python normalization, globals or runtime domains. + +Supported features include elementwise arithmetic, comparisons and chains, +Boolean logic, local assignments, branches, bounded loops, and explicit output +conversions. Boolean operands participate in numeric arithmetic as zero/one; +truth conversion occurs at a Boolean output or explicit ``bool()`` call. + +External functions, callbacks, object operations and unsupported dynamic indexing +are rejected during export and independently by native import; there is no Python fallback. + +Integer overflow, out-of-range narrowing, non-finite/out-of-range float-to-integer +casts and integral zero divisors raise checked evaluation errors. The interpreter +establishes its floating-point environment and restores the caller's environment. +Callers must keep data and intermediates in the defined domains; +static validation cannot prove those conditions. This is not a sandbox for +untrusted source or arbitrary data. NaN payloads are not guaranteed. + +Use ``blosc2.validate_portable_dsl(source, input_dtypes, output_dtype)`` to check +membership without execution or JIT. It returns validity, a status category, +and optional source diagnostics. Import/export errors raise +``blosc2.PortableArtifactError`` with a stable ``status`` attribute. Missing +returns, zero range steps, and loop-cap failures are runtime evaluation errors; +failed output contents are unspecified. Empty elementwise evaluations validate +bindings without execution; block-scalar reductions use their specified empty identities/errors. + +Builds and execution +-------------------- + +Draft logical partitions and persistence +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +For a validated 1.0 kernel, ``kernel.lazy(inputs, partitions=(...))`` binds an +immutable logical C-order block grid. This grid is independent of compressed +operand chunks/blocks. Elementwise output retains the original domain; +``block_scalar`` output has one item per logical partition (the grid shape). +Scalar returns under lane-varying branches/loops, or inside loops with +lane-varying break/continue, reject as ambiguous output—even if their scalar +expressions match. Uniform reduction conditions and coherent scalar control +flow remain supported; varying loops may rejoin before a top-level scalar return. +Slices evaluate intersecting **original complete groups** before selecting result +lanes. ND coordinates retain the original domain and group origin. Rechunking the +materialized result changes storage, never reduction membership:: + + lazy = kernel.lazy({"x": stored_array}, partitions=(32, 64)) + values = lazy[1:3, ::2] + result = lazy.compute(chunks=(8, 16), blocks=(4, 8)) + lazy.save("recipe.b2nd") + reopened = blosc2.open("recipe.b2nd") + +Native JSON records, signatures and logical partitions persist through disk +carriers, frames, structured MessagePack and EmbedStore/DictStore/TreeStore, +including arithmetic expressions containing portable carriers. Operands must +have persistent references; failures preflight before overwriting destinations. +Import never reconstructs a Python function. Safe arithmetic envelopes permit +only bound-name primitive arithmetic/Boolean expressions, not calls or attributes. + +New DSLKernel-backed LazyUDF saves automatically normalize authoring and typed +captures, validate draft 1.0 natively and persist artifact/bindings/context. The +same preflight applies to frames, MessagePack, stores and nested arithmetic +references. Python UDFs and noncompliant normalized kernels reject before +destination writes; there is no source fallback. Positional scalar arguments +become typed constants, array arguments retain their parameter names, and the +current output shape and logical block partitions are preserved. A block-scalar +return cannot silently replace an elementwise LazyUDF shape: author it through +``export(cardinality="block_scalar")`` and ``PortableKernel.lazy`` +with explicit partitions instead. Storage chunk boundaries must not split the +declared uniform logical block grid. + +Historical source-backed files require explicit ``deserialize='full'``; +that policy propagates through nested references. Loaded legacy recipes are not +automatically migrated by saving. CTable legacy computed/generated DSL metadata +has the same explicit policy gate. The older table vector-column DSL API lacks +an explicit row-domain contract and cannot be silently converted to independent +rows when loading. New registrations use the independent-row contract below. +``msgpack_unpackb()`` also defaults to safe decoding. Active reconstruction needs +explicit ``deserialize='full'``; container readers propagate their effective +policy through nested values instead of relying on the helper's default. + +Draft native table transformers +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Scalar stored columns bind to native transformers by name:: + + table.add_computed_column("total", kernel, inputs={"x": "amount"}) + table.add_generated_column("stored_total", values=kernel, + inputs={"x": "amount"}) + +These APIs also accept a newly authored ``DSLKernel`` directly. Specify the +output dtype when it differs from input type promotion. Normalization, capture snapshots and native validation finish +before column registration or destination mutation:: + + table.add_computed_column( + "twice", blosc2.DSLKernel.from_source("def twice(x):\n return x * 2\n"), + inputs={"x": "amount"}, dtype="int64") + +For a fixed-shape row reduction, additionally specify +``cardinality="block_scalar"``. Independent-row grouping is the contract of +kernel registration; there is no ``row_domain`` option or separate +``add_portable_*`` API. Positional input lists and column-bound DSL LazyUDFs +also adopt this contract on new registration. String/lazy expressions and +non-kernel row transformers retain their existing behavior. + +The independent domain means **each scalar row is one original +one-lane group**, not a storage block or a changing table-wide reduction. Rank-one +coordinates are row-local: shape ``(1,)``, origin ``(0,)``, ``_i0 == 0`` and +``_n0 == 1``. Block-scalar and elementwise kernels both yield one scalar per row. +Named bindings may be empty for constant/ND constructors. Appending, refreshing, +deleting rows, materializing and compact-copying retain this mapping. Artifacts, +bindings and fixed row shapes survive table disk/frame round trips, with native +validation before binding and again before saving. Fixed-width numeric/string +signatures are immutable. Fixed-shape ndarray columns also support scalar native +row reductions: each complete row is one group, its broadcast row shape is the +logical ND domain, and its origin is zero. Scalar columns can broadcast within +that row without changing coordinates. Shape/cardinality incompatibilities reject +before registration. Multi-row table partitions and vector-valued row outputs +are not implicitly admitted. The draft remains subject to conformance and +external platform release gates. + +The native artifact loader is enabled by default in Python package builds. +Custom builds may disable it with ``MINIEXPR_BUILD_ARTIFACT=OFF``; import then +raises ``NotImplementedError``. The optional adapter uses pinned, MIT-licensed +yyjson; the raw native compiler does not depend on it. + +Draft 1.0 uses the typed interpreter. ``jit`` and compiler pragmas are preferences +only and currently fall back to interpretation; a required-JIT artifact rejects. +Semantic evaluation errors never retry the kernel. Artifacts +enforce strict FP independently of host defaults. Host while-loop limits remain +execution policy rather than artifact constants. + +The authoritative language and artifact specifications are maintained in +miniexpr under ``doc/dsl-spec/1.0.md`` and ``doc/dsl-spec/artifact-1.0.md``. +Python-Blosc2 pins the published native revision that passed the native platform +matrix. Native CI is distinct from Python stock-wheel certification. + +API +--- + +.. autoclass:: blosc2.PortableKernel + :members: + +.. autoclass:: blosc2.PortableArtifactError + +.. autofunction:: blosc2.validate_portable_dsl diff --git a/doc/reference/save_load.rst b/doc/reference/save_load.rst index 493447210..ba4e316d4 100644 --- a/doc/reference/save_load.rst +++ b/doc/reference/save_load.rst @@ -21,3 +21,20 @@ Save and load .. autofunction:: save_tensor .. autofunction:: load_tensor .. autofunction:: from_cframe + +Deserialization policy +~~~~~~~~~~~~~~~~~~~~~~ + +Validated Menudet artifacts load natively without reconstructing Python code. +Historical Python-specific recipes require explicit ``deserialize="full"``; +the selected policy propagates through nested containers and references. +Ordinary LazyExpr expressions, including supported numerical calls, reductions, +methods and indexing, load under the default ``deserialize="safe"`` policy +with the existing expression validation. Full-only nested operands (such as +legacy kernels or proxies) still require explicit opt-in. Legacy table-kernel +recipes loaded with ``"full"`` retain their old block/batch-dependent grouping; +new registrations use independent-row Menudet semantics. + +.. autodata:: DeserializeMode + +.. autoexception:: UnsafeDeserializationError diff --git a/doc/reference/utilities.rst b/doc/reference/utilities.rst index a9b0676c1..12dfbacf3 100644 --- a/doc/reference/utilities.rst +++ b/doc/reference/utilities.rst @@ -8,9 +8,111 @@ A series of utilities are provided to work with expressions in a more convenient Functions --------- .. autofunction:: evaluate +.. autofunction:: re_evaluate +.. autofunction:: prepare_evaluate +.. autoclass:: PreparedEvaluator + :members: evaluate + :special-members: __call__ .. autofunction:: get_expr_operands .. autofunction:: validate_expr +Reusable evaluation +------------------- + +Prepare an operand-free recipe and supply a mapping for each execution:: + + evaluator = blosc2.prepare_evaluate("x + y * 2") + result = evaluator({"x": x, "y": y}, out=out) + result = evaluator({"x": another_x, "y": another_y}, out=another_out) + +The recipe validates the approved expression grammar at construction. Numerical +preparation is lazy and reuses the existing bounded signature caches. Shapes and +dtypes may change between calls; input and output arrays are never retained by +the recipe. Concurrent calls use independent bindings. There is no implicit +last-expression state or caller-variable capture. Per-call options override +construction options without mutating the recipe. + +NumExpr-style repetition +----------------------- + +For compatibility-oriented loops, ``re_evaluate()`` repeats the last successful +public ``evaluate()`` call in the current thread:: + + blosc2.evaluate("x + y * 2", local_dict={"x": x, "y": y}, out=out) + blosc2.re_evaluate(local_dict={"x": another_x, "y": another_y}) + +The expression and options are remembered, but operands are looked up anew. +Without dictionaries, the caller's locals/globals supply the operands. A live +explicit output is reused through a weak reference; if it has been collected, +a fresh result is allocated. Implicitly allocated results are never reused. + +State is thread-local. Failed evaluations, nested evaluations and explicit +``PreparedEvaluator`` calls do not replace it. Calling ``re_evaluate()`` before +a successful ``evaluate()`` in that thread raises ``RuntimeError``. Unlike +NumExpr's unchecked shortcut, Blosc2 retains shape, dtype and destination +validation. This API is convenience compatibility, not a guarantee of lower +overhead than an explicit prepared evaluator. Use explicit evaluators for +interleaved expressions or independent callers sharing a thread. + +Evaluation options +------------------ + +Options are validated before choosing a backend, including for Fortran outputs +and empty inputs. Unknown keywords and invalid values raise an error before +destination writes. + +* ``order`` and ``casting`` describe destination allocation/conversion. +* ``optimization`` accepts ``none``, ``moderate`` and ``aggressive`` as compatibility + hints. Neither native execution nor the NumPy fallback reproduces NumExpr's + algebraic rewrites; NumPy-style numerical semantics remain authoritative. + +``truediv``, ``sanitize`` and ``disable_cache`` are no longer accepted, including +by prepared evaluators. Division follows NumPy semantics (use ``//`` for floor +division), validation follows the safe/full expression policy, and preparation +caches are managed automatically. + +Eligible ``evaluate()`` expressions default to native interpretation, as do +``prepare_evaluate()`` and ``re_evaluate()``. This follows the shared native +automatic policy, not an evaluator-specific override: single-return expressions +are interpreted and multi-statement Menudet programs prefer JIT. Explicit +global/context JIT settings and the ``ME_DSL_JIT`` environment +override retain their existing precedence. To opt in for repeated computations:: + + with blosc2.jit_options(jit=True): + result = blosc2.evaluate("x + y * 2", local_dict={"x": x, "y": y}) + +Set ``jit_backend="cc"`` in that context to request the system compiler instead +of TCC. JIT remains best effort. Accelerate remains an explicit opt-in; the +``optimization`` hint does not select it or relax numerical guarantees. + +Overlapping NumPy inputs are snapshotted before writing an explicit output; +this may require temporary memory proportional to the overlapping operands. +Empty sums/products use NumPy identities, and empty extrema raise without an +explicit identity. Native output descriptors support validated Fortran, transposed, +stepped and reversed destinations with bounded scratch. Unsupported operations +retain explicit NumPy fallbacks. NumExpr is not a runtime dependency; +``blosc2.numexpr`` remains a compatibility placeholder equal to ``None``. + +NumExpr migration +----------------- + +Installing NumExpr does not enable another Blosc2 backend, and +``NUMEXPR_NUM_THREADS`` / ``NUMEXPR_MAX_THREADS`` do not configure Blosc2 workers. +Use ``blosc2.set_nthreads()`` and :ref:`JITOptions` for native execution policy. +``jit=False`` requests native interpretation where supported, not NumExpr. +Optional benchmark scripts may still use NumExpr as an independent reference. + +The legacy internal ``ne_evaluate`` spelling delegates to the backend-neutral +chunk evaluator; it neither imports nor invokes NumExpr. Native preparation can +decline an unsupported signature to explicit NumPy semantics. An error after +native execution starts propagates instead of replaying the operation through +another backend, including for compression prefilters and scalar reductions. + +NumPy fallbacks may create expression intermediates. Compressed/mixed inputs +remain tile-local where the operation permits it; inherently global operations +retain their documented materialization requirements. Interpreter performance +is workload-dependent and is not claimed to match NumExpr universally. + Decorators ---------- .. autofunction:: jit diff --git a/examples/menudet.py b/examples/menudet.py new file mode 100644 index 000000000..f2ed894f1 --- /dev/null +++ b/examples/menudet.py @@ -0,0 +1,32 @@ +"""Menudet 1.0 draft: one kernel, array and independent table-row execution.""" + +from dataclasses import dataclass + +import numpy as np + +import blosc2 + +author = blosc2.DSLKernel.from_source("def affine(x):\n return x * 2.0 - 1.0\n") +kernel = blosc2.PortableKernel.from_json(author.export({"x": "float64"}, "float64")) +x = np.arange(6, dtype="float64") +values = kernel.lazy({"x": x}, partitions=(3,))[:] +np.testing.assert_array_equal(values, [-1, 1, 3, 5, 7, 9]) +print("Array:", values) + + +@dataclass +class Row: + amount: float = 0.0 + + +table = blosc2.CTable(Row, new_data={"amount": x.tolist()}, create_summary_index=False) +table.add_computed_column("adjusted", kernel, inputs={"x": "amount"}) +np.testing.assert_array_equal(table["adjusted"][:], values) +print("Table:", table["adjusted"][:]) + +# A reduction is a different result contract: one scalar per ORIGINAL group. +total = blosc2.DSLKernel.from_source("def total(x):\n return block_sum(x)\n") +record = total.export({"x": "float64"}, "float64", cardinality="block_scalar") +totals = blosc2.PortableKernel.from_json(record).lazy({"x": x}, partitions=(3,))[:] +np.testing.assert_array_equal(totals, [3, 12]) +print("Block totals:", totals) diff --git a/examples/menudet_decorator.py b/examples/menudet_decorator.py new file mode 100644 index 000000000..f576dfd7c --- /dev/null +++ b/examples/menudet_decorator.py @@ -0,0 +1,24 @@ +"""The same arithmetic as a LazyExpr and a decorated Menudet kernel.""" + +import numpy as np + +import blosc2 + + +@blosc2.menudet +def adjusted(x, y): + return x + (y - 1) + + +@blosc2.menudet +def typed_adjusted(x: np.float64, y: np.float64) -> np.float64: + return x + (y - 1) + + +x = np.array([1, 2, 3], dtype="float64") +y = np.array([4, 5, 6], dtype="float64") +expr = blosc2.lazyexpr("x + (y - 1)", {"x": x, "y": y}) +print("LazyExpr:", expr[:]) +print("Menudet:", adjusted(x, y)[:]) +print("Annotated Menudet:", typed_adjusted(x, y)[:]) +print("Menudet JIT:", adjusted.specialize(x, y).has_jit) diff --git a/examples/ndarray/ironpill1.ipynb b/examples/ndarray/ironpill1.ipynb index 73d67aea7..f948b6d23 100644 --- a/examples/ndarray/ironpill1.ipynb +++ b/examples/ndarray/ironpill1.ipynb @@ -249,7 +249,7 @@ "metadata": {}, "source": [ "## Conclusion\n", - "Blosc2 remains 5x faster than NumPy even when using a memory-optimised approach for the latter, and moreover preserves the more intuitive, concise and pythonic ``sum`` syntax. In the last cell we checked that Numpy and Blosc2 give approximations which are the same (up to rounding errors), and we can also see that NumPy and Blosc2 approximate the square wave below. By using compressed, chunked arrays which can be fetched rapidly from disk, combined with the hyper-fast compiled-code library `numexpr` behind the scenes, Blosc2 can accelerate your (data-)scientific computations!" + "The recorded benchmark shows Blosc2 outperforming NumPy while preserving concise ``sum`` syntax. The results agree up to rounding errors. Current Blosc2 uses native miniexpr interpretation and optional JIT for supported expressions, with explicit NumPy fallbacks; NumExpr is no longer a runtime dependency. Re-run the notebook to measure your hardware and current versions." ] }, { diff --git a/examples/ndarray/portable_artifact.py b/examples/ndarray/portable_artifact.py new file mode 100644 index 000000000..363bcdd9f --- /dev/null +++ b/examples/ndarray/portable_artifact.py @@ -0,0 +1,25 @@ +####################################################################### +# Copyright (c) 2026, Blosc Development Team +# SPDX-License-Identifier: BSD-3-Clause +####################################################################### +"""Snapshot a scalar capture and execute the portable artifact without its author.""" + +import numpy as np + +import blosc2 + +SCALE = 2.0 + + +@blosc2.dsl_kernel +def scaled(x): + return x * SCALE + + +if __name__ == "__main__": + artifact = scaled.export({"x": "float64"}, "float64") + SCALE = 99.0 + imported = blosc2.PortableKernel.from_json(artifact, jit=False) + values = imported.evaluate({"x": np.arange(4, dtype=np.float64)}) + np.testing.assert_array_equal(values, [0, 2, 4, 6]) + print(values) diff --git a/plans/contiguous-jit-lowering.md b/plans/contiguous-jit-lowering.md new file mode 100644 index 000000000..bf61e1844 --- /dev/null +++ b/plans/contiguous-jit-lowering.md @@ -0,0 +1,155 @@ +# Contiguous JIT lowering: first implementation pass + +Follow-up: [no-jit-and-small-math.md](no-jit-and-small-math.md) records the new +bounded vector interpreter and small-math scheduling results. The no-JIT and +small-workload limitations below describe this earlier pass. + +This pass targets regular contiguous numerical maps, not strided-store tuning or +unchecked numerical transformations. Explicit `jit=False` still means no JIT; +the large no-JIT arithmetic gap is not fixed by secretly compiling that mode. + +Native implementation: `f19aed813d0153342a9f2e4238c8f0fc0003b9f4`; both Python +build/qualification pins identify this revision. It is a local commit until +published; local builds use the native source override. + +## Findings and changes + +1. `evaluate_chunk()` forced `jit=False`, even when the surrounding evaluation + allowed native compilation. It now requests the existing qualified lowering + when JIT is enabled/default. Explicit no-JIT and unsupported graph backend/FP + policies retain the interpreter. Cached plans do not retain arrays. Runtime + failures propagate without a NumPy retry. +2. A kernel's `has_jit=True` does not imply every operation is compiled. Integral + `minimum`, `maximum`, `fmin`, `fmax` and `fmod` could enter the checked host + bridge, reconstruct an operation and evaluate it in the scalar interpreter + for each lane. These matching-dtype operations now lower directly to typed C + comparisons/remainders. Signed minimum / -1 and zero-divisor guards remain; + floating and mixed-domain operations keep their established semantics. +3. Native graph safety metadata now admits integral extrema and identity rounding + operations for host task partitioning. Numerical checks in child expressions + are not weakened; checked casts, integer power and checked scalar subtrees + still do not gain parallel admission through an enclosing math function. +4. Chunk execution uses bounded 64K tiles only for certified partitionable maps. + It stays serial within the caller's chunk worker, avoiding nested worker pools. + +The generated source revision advances to r29. Native tests verify that integral +extrema/remainder kernels use no checked-operation callback, as well as exact +interpreter/JIT values, masking, signed/unsigned boundaries and FP status. Python +tests cover dispatch/policy/output identity, error propagation and real native +host tasks rather than duplicating the native dtype matrix. + +## Benchmark qualification + +The resident benchmark now checks result dtype before timing, not only values. +For example, NumExpr promotes `minimum(int64, int64)` to float64, whereas NumPy +and Blosc2 preserve int64. Comparing the two with a float64 destination measures +an extra output conversion on the Blosc2 side, not matching integer kernels. +Such intentional promotion differences are now `N/A`. + +For same-dtype integer comparisons, an equivalent NumExpr reference can use +`where(x < y, x, y)` / `where(x > y, x, y)`. Integer `fmod` can be compared with +`x % y` only for strictly positive inputs; the operations differ on negative +inputs. Any reported comparison using these spellings must identify them. + +## Initial measurements + +M4 Pro, eight workers, 8M contiguous elements, system-CC JIT, warmed explicit +destinations, seven alternating samples. Old measurements use the preceding +independently built wheel; new measurements use rebuilt isolated extensions. + +| int64 recipe | Before ms | After ms | NumExpr equivalent ms | +| --- | ---: | ---: | ---: | +| `minimum(x,y)` | 792.221 | 1.223 | 1.194 (`where(x < y,x,y)`) | +| `maximum(x,y)` | 803.057 | 1.185 | 1.192 (`where(x > y,x,y)`) | +| `fmod(x,y)` | 123.096 | 1.377 | 1.215 (`x % y`, positive inputs only) | + +These gains include removal of scalar-operation interpretation **and** native +parallel admission, not code generation alone. NumExpr controls in the separate +before run were 1.341/1.229/1.367 ms respectively. These remain preliminary local +measurements, not cross-platform qualification or universal speedup claims. + +To reproduce the integer comparison without NumExpr's dtype promotion, use the +`blosc2` conda Python and `ME_DSL_JIT_COMPILER=cc` with this core benchmark: + +```python +from statistics import median +from time import perf_counter +import blosc2 +import numexpr as ne # external reference only +import numpy as np + +blosc2.set_nthreads(8) +ne.set_num_threads(8) +x = np.arange(8_000_000, dtype="int64") % 97 + 1 +y = x[::-1].copy() +out = np.empty_like(x) +for expr, ref in [ + ("minimum(x,y)", "where(x < y,x,y)"), + ("maximum(x,y)", "where(x > y,x,y)"), + ("fmod(x,y)", "x % y"), +]: + calls = [ + lambda: blosc2.evaluate(expr, local_dict={"x": x, "y": y}, out=out), + lambda: ne.evaluate(ref, local_dict={"x": x, "y": y}, out=out), + ] + for call in calls: + for _ in range(2): + assert call() is out + times = [[], []] + for sample in range(7): + for i in [0, 1] if sample % 2 else [1, 0]: + start = perf_counter() + calls[i]() + times[i].append(1000 * (perf_counter() - start)) + print(expr, ref, [median(values) for values in times]) +``` + +The measured run additionally checked output values against NumPy before timing. + +For a serial float64 chunk, `x*2+y` took **402.326 ms before** despite `jit=True`, +and **1.769 ms after**, with no nested pool. Explicit `jit=False` remained around +**391–397 ms**. This improves actual JIT dispatch, not interpreter-only execution. +Cold compilation is excluded; these are steady-state throughput measurements. + +The existing regular-map benchmark remains competitive at 8M float64 elements: + +| Recipe | NumExpr ms | Blosc2 JIT ms | +| --- | ---: | ---: | +| Linear | 1.164 | 1.183 | +| Polynomial | 1.549 | 1.158 | +| Square-root norm | 1.481 | 1.089 | +| Sine + cosine | 3.845 | 4.200 | +| Selection | 1.373 | 1.144 | + +These used 15 shuffled samples after warmup. Small workloads remain a gap: +100K-element sine/cosine was **0.426 ms** versus NumExpr **0.129 ms**, and norm +**0.189 ms** versus **0.102 ms**. This pass does not claim universal parity. + +The generic resident benchmark includes extrema recipes and now marks the +NumExpr integral-promotion mismatch `N/A` rather than timing extra output casting. +It still accepts the original regular-map suite for wider follow-up comparisons. + +## Qualification + +- Real TCC native interpreter/JIT parity matrix passed, including the integral + dtype/mask/boundary matrix and assertions that these kernels have no checked + operation bridge. +- System-CC full parity passed. The compact CC gate hit its 180-second timeout + during concurrent cold-cache compilation, then passed in 38.9 seconds on rerun; + no timeout or numerical evidence requirement was relaxed. +- Native graph/array checks passed: **11 ASan/UBSan**, **11 actual wasm32**. + This does not add a portable WASM JIT ABI; wasm32 retains its existing backend. +- Standalone native full suite: **354 passed** on the final rerun. +- Python full `tests/` suite: **11,674 passed**, 76 skipped, 12,907 deselected. + Targeted integration/compatibility checks: **309 passed** with system compiler + JIT enabled. +- Independently built wheel with the NumExpr module **and** distribution metadata + absent: **165 passed**, 24 external-reference cases skipped. Wheel metadata + still contains no NumExpr runtime requirement. Configured doctests: **120 + passed**, two skipped, in an isolated working directory. + +No fast-math flags, unchecked float-to-int casts, changed reduction order or +NumExpr runtime dependency were introduced. Generic no-JIT interpreter +throughput, floating-operation callback inlining, and remaining reduction/DSL +scheduling migration remain further work; this pass does not finish every item +in the broader native-layer plan. diff --git a/plans/enable-tcc-menudet-wams32.md b/plans/enable-tcc-menudet-wams32.md new file mode 100644 index 000000000..a4ce97138 --- /dev/null +++ b/plans/enable-tcc-menudet-wams32.md @@ -0,0 +1,551 @@ +# Enable TCC JIT for Menudet on wasm32 + +Status: bridge-free wasm32 first slice implemented and qualified under Emscripten +Node (main and side modules), headless Chromium (main and side modules), and a +fresh Python-Blosc2 Pyodide wheel through the public API. Performance remains +workload- and target-dependent; typed bridges remain deferred. + +## Objective + +Enable the existing TCC-to-WebAssembly runtime to execute a deliberately narrow, +semantically exact subset of Menudet portable 1.1 kernels under Emscripten and +Pyodide. Start with bridge-free elementwise kernels, including exact `int64` and +`uint64` values held in WebAssembly memory. Unsupported kernels must continue +through the interpreter without changing results, status, masking, diagnostics, +or the public best-effort meaning of `jit=True`. + +This is not a request to enable all host JIT lowering on wasm32. In particular, +JavaScript `Number` must never transport an exact 64-bit integer, and host function +pointers stored in the generated kernel's `inputs[]` table must not be assumed to +have the same ABI in a separately instantiated wasm module. + +## Starting point and blocker + +Paths prefixed with `miniexpr/` and `minicc/` refer to sibling repositories, +available locally as `../miniexpr` and `../minicc` during development. + +| Area | Main files | +| --- | --- | +| Menudet typed C lowering and wasm exclusion | `miniexpr/src/dsl_portable_jit.c` | +| wasm32 TCC compilation, source patching, instantiation and cache | `miniexpr/src/dsl_jit_backend_wasm32.c` | +| JIT IR and runtime dispatch | `miniexpr/src/dsl_jit_ir.*`, `miniexpr/src/dsl_jit_runtime_nonhost.c` | +| Bridge definitions and program state | `miniexpr/src/dsl_jit_bridge_contract.h`, `miniexpr/src/dsl_compile_internal.h` | +| Browser/side-module helper | `miniexpr/src/me_jit_glue.js`, `miniexpr/tests/test_dsl_jit_side_module.c` | +| wasm native tests | `miniexpr/tests/test_dsl_jit_side_module.c`, `miniexpr/tests/test_me_jit_glue_smoke.js` | +| Python wasm integration | `CMakeLists.txt`, `src/blosc2/wasm_jit.py`, `tests/test_menudet_jit.py` | +| Pyodide build workflow | `.skills/wasm32-pyodide-dev/SKILL.md` | + +`pj_prepare_source()` currently rejects every Emscripten target. That guard is +necessary because the existing wasm adapter patches legacy generated source by +replacing `int64_t`/`uint64_t` declarations and casts with 32-bit types. Menudet's +generated source requires true 64-bit values for typed array elements, modular +integer operations, constants, checked arithmetic state, ND metadata, and some +bridge arguments. Removing the guard while retaining that rewrite would silently +miscompile kernels. + +The exported kernel itself can retain a wasm32-compatible JavaScript signature: + +```c +int me_dsl_jit_kernel(const void *const *inputs, void *output, int count); +``` + +All three values cross JavaScript as wasm `i32`; typed values remain in wasm linear +memory. Internal generated code may use wasm `i64`, `f32`, and `f64`. The first +slice must not make an `i64` cross the JavaScript boundary or an indirect callback +boundary. + +## Required behavior + +| Situation | Expected behavior | +| --- | --- | +| Explicit portable 1.1 `jit=True`, eligible bridge-free kernel | Compile with TCC, instantiate wasm, and execute the generated kernel | +| `int64`/`uint64` input or output | Preserve all 64 bits in wasm memory, including values outside JavaScript's exact-number range | +| Participating mask | Skip inactive lanes before loads, arithmetic, and stores | +| Unsupported operation, bridge, reduction, rank feature, or ABI | Do not generate/compile a wasm Menudet kernel; use the interpreter | +| TCC compilation or wasm validation/instantiation failure | Clean up and use the interpreter; warnings remain opt-in | +| Missing side-module helpers | Use the interpreter, as today | +| `jit=False` | Do not attempt JIT | +| Native host target | Preserve current TCC/CC lowering and bridge behavior | + +No fallback may turn a valid operation into an exception merely because JIT is +unavailable. Existing expression validation errors and runtime semantic errors +must remain errors rather than being hidden as JIT fallback. + +## First-slice eligibility boundary + +The initial wasm32 slice is intentionally bridge-free. It should admit only +operations whose complete behavior is emitted into the generated module: + +- elementwise loads and stores for Boolean, signed/unsigned integer, float32 and + float64 arrays; +- same-width modular integer `+`, `-`, `*`, unary `-`, and audited bitwise forms + already lowered without callbacks; +- float32/float64 `+`, `-`, `*`, and `/`, subject to the existing portable + exception/status contract that wasm32 can actually observe; +- same-domain integer comparisons and ordinary finite floating comparisons only + if lowering proves they require no comparison bridge; +- Boolean operations, lazy `where`, branches, and lane-local bounded loops when + every contained expression remains bridge-free; +- participating masks and simple uniform captures whose values are read from wasm + memory without checked conversion or JavaScript transport. + +Initially reject: + +- checked-operation, integer-operation, comparison, predicate, and math callbacks; +- every generated kernel with nonzero `portable_jit_nchecked`, + `portable_jit_niops`, `portable_jit_ncomparisons`, `portable_jit_npreds`, + `portable_jit_nmath`, `portable_jit_nmath2`, or `portable_jit_nmath3`; +- reductions and scalar-output recipes; +- ND reserved symbols and ND metadata until their exact `int64_t` layout has a + dedicated wasm test; +- local scratch arrays transported through nested pointer tables; +- weak/scalar conversions that can report overflow or otherwise need a bridge; +- NaN-sensitive comparisons and math operations whose interpreter parity depends + on a callback or floating-status behavior not observable on wasm32; +- accelerated SLEEF/Accelerate math policies and relaxed floating-point modes. + +Eligibility must be based on typed lowering state, not source-text heuristics. A +kernel that becomes ineligible after partial lowering must release its generated +source/IR and leave the program in the normal interpreted state. + +## Task A: separate Menudet source from legacy wasm source rewriting + +### A1. Identify generated-source capabilities explicitly + +- [x] Add a generated-source kind or capability field to the JIT program/IR, for + example legacy wasm-patchable versus portable typed wasm. Do not infer this from + comments or search for type names in C source. +- [x] Set the capability in `dsl_portable_jit.c` only after portable lowering and + wasm eligibility checks succeed. +- [x] Include the source kind, portable lowering revision, semantic profile and + wasm ABI revision in the runtime cache identity. A legacy patched module must + never alias a typed Menudet module. +- [x] Preserve native source behavior: native TCC and CC continue to consume the + existing portable C source without wasm-specific substitutions. + +### A2. Split backend preparation paths + +- [x] Refactor `dsl_wasm32_patch_source()` into an explicitly legacy-only path. + Keep existing substitutions unchanged for already-supported legacy kernels. +- [x] Add a typed portable wasm preparation path that does **not** replace + `int64_t`, `uint64_t`, their casts, constants, or helper signatures. +- [x] Avoid broad textual rewriting in the new path. Generate the required wasm + entry signature and preamble from `dsl_portable_jit.c`, or apply narrowly scoped, + marker-backed substitutions whose inputs are tested byte-for-byte. +- [x] Compile with `-nostdlib -nostdinc` as today, while ensuring the generated + portable preamble supplies everything it uses. Audit `stdint.h`, `limits.h`, + `string.h`, `memcpy`, compound literals, unions, `UINT64_C`, and `restrict` + against MiniCC's wasm frontend. +- [x] Add generated compile-time width checks for 8/16/32/64-bit integer typedefs + where MiniCC supports them. Compilation failure must remain recoverable. + +## Task B: define a wasm32-safe kernel ABI + +### B1. Keep boundary values wasm32-sized + +- [x] Give the exported wasm kernel an explicit count type that lowers to `i32`. + Validate negative counts before converting to an internal nonnegative lane count. +- [x] Keep input-table pointers, input pointers, output pointers, masks, and status + pointers as wasm32 addresses. Check assumptions about `uintptr_t` and pointer size. +- [x] Use an internal `int64_t` only where Menudet semantics require it. Prefer a + checked `uint32_t`/`size_t` lane index for memory addressing in the first slice, + so pointer arithmetic cannot wrap through a signed 32-bit expression. +- [x] Validate `count * itemsize` and every derived address range before execution, + using the existing caller bounds where available. Do not rely on a wasm trap as + ordinary bounds validation. +- [x] Retain `addFunction(fn, "iiii")` for the first-slice exported function and + document why no `i64` is exposed to JavaScript. + +### B2. Keep exact values inside wasm + +- [x] Confirm MiniCC emits wasm `i64` loads, stores and arithmetic when compiling + exact-width C types without the legacy rewrite. +- [x] Ensure signed conversion helpers preserve the same two's-complement modular + bit patterns as native portable lowering. Do not use JavaScript `Number`, JSON, + or double casts as an intermediate representation. +- [x] Verify alignment behavior for 64-bit typed loads/stores. Either prove callers + supply the required alignment or generate wasm-safe unaligned accesses/copies. +- [x] Keep constants such as `INT64_MIN`, `UINT64_MAX`, shift counts and literal + suffixes intact through MiniCC parsing and wasm emission. + +## Task C: implement fail-closed wasm eligibility + +- [x] Move the unconditional `__EMSCRIPTEN__` rejection in `pj_prepare_source()` + behind a dedicated wasm eligibility decision rather than deleting it outright. +- [x] Check the target after typed lowering has populated bridge counters, but + before publishing `jit_c_source` and its fingerprint. +- [x] Require elementwise output, supported rank policy, supported dtypes, no ND + metadata, no scratch pointer table, and zero bridge counters for the first slice. +- [x] Audit operations that emit apparently local helper code but still depend on + host status, floating environment, or interpreter callbacks. Add explicit flags + where bridge counters alone are insufficient. +- [x] Emit one concise trace reason for each broad rejection category: bridge ABI, + reduction/scalar output, ND context, scratch locals, unsupported semantics, or + backend/compiler failure. +- [x] Ensure failed specialization with runtime constants cannot leave stale bridge + counters, source, IR, fingerprint, or cache state on the program. +- [x] Keep `jit=True` best effort. Do not add a Python-visible strict-JIT mode as + part of this work. + +## Task D: update wasm compilation and instantiation + +- [x] Dispatch legacy and portable source kinds separately in + `dsl_jit_compile_wasm32()`. +- [x] Register no host symbols for a first-slice portable kernel except unavoidable + runtime primitives whose signatures are explicitly audited. Prefer generated + local helpers over imported `memcpy`/`memset` for small fixed-width operations. +- [x] After TCC output, validate the module's imports and exported kernel signature + before instantiation. Reject unexpected function, memory, table, or global imports. +- [x] Preserve shared linear-memory import patching and remove any exported module + memory exactly as the current adapter requires. +- [x] Keep module compilation and instantiation errors recoverable and warning-free + by default. Opt-in traces should identify source kind and failing phase. +- [x] Replace the fixed `/tmp/me_jit_kernel.wasm` name with a collision-safe or + in-memory mechanism before enabling concurrent portable compilation. If MiniCC + cannot emit to memory, create a unique virtual-FS path and remove it on every + success and failure path. +- [x] Audit cache ownership: cached function-table entries retain required scratch + memory, eviction removes the JS function, and failed modules retain neither. +- [x] Include the portable wasm ABI revision in positive and negative cache keys. + +## Task E: native wasm tests for the first slice + +### E1. Generated-source and eligibility tests + +Eligibility is checked through the artifact-level differential harness in both +Emscripten configurations (and the browser target) rather than a separate +host-only predicate copy; that keeps the assertions on the production lowering. + +- [x] Cover eligibility acceptance/rejection through the artifact-level wasm + differential harness, including generated-source width checks and the exported + signature, rather than a separate copy of the predicate. +- [x] Assert portable wasm source retains `int64_t`/`uint64_t` and 64-bit exact + values through the boundary corpus; the preamble asserts fixed widths/pointer + size at compile time. +- [x] Assert legacy source still receives its existing compatibility patch and + does not use the portable path (existing legacy wasm regression). +- [x] Assert math, predicate, checked-cast, mixed-comparison and reduction + families each reject the first-slice wasm path and preserve values. +- [x] Assert native portable JIT source and host tests are unchanged. + +### E2. Actual Emscripten execution + +- [x] Extend `test_dsl_jit_side_module.c` or add a focused portable wasm test that + requires `me_expr_has_jit_kernel()` for eligible cases, rather than merely + accepting interpreter parity. +- [x] Test `int64` values around `0`, `-1`, `INT32_MIN/MAX`, `2^53`, `2^63-1`, and + `INT64_MIN`; test `uint64` values around `2^32`, `2^53`, `2^63`, and `UINT64_MAX`. +- [x] Test passthrough, addition, subtraction, multiplication, unary negation, + comparisons and selected bitwise operations, including modular wraparound. +- [x] Test float32 and float64 arithmetic with finite normal, subnormal, signed-zero, + infinity and NaN inputs where the operation is eligible. Compare bits where the + semantic contract requires bits and classify unavoidable wasm FP differences. +- [x] Test all-active, mixed and all-inactive masks. Inactive lanes must not read + invalid input or trigger an otherwise participating semantic error. +- [x] Test lazy `where`, `if`/`elif`/`else`, and bounded loops with eligible bodies. +- [x] Test zero length, one lane, odd lengths, tile boundaries and the largest lane + count practical in CI. +- [x] Assert the contiguous `me_artifact_eval_ex` fast ABI rejects naturally + unaligned pointers; Python/array-view paths normalize or gather such views + before execution instead of passing them to typed wasm loads. +- [x] For every rejected category, assert `has_jit == false` and interpreter values + and errors remain correct. +- [x] Run both main-module and side-module helper configurations. Unregistering + side-module helpers restores clean interpreter fallback. +- [x] Run repeated compile/free/cache-eviction cycles; this wasm build is + single-threaded, so concurrent compilation is not applicable. + +## Task F: Python-Blosc2/Pyodide integration + +- [x] Update the local miniexpr source override first; change Python-Blosc2's + bundled revision only after the miniexpr implementation and tests are stable. +- [x] Add focused Python tests using the public `@blosc2.menudet`/portable artifact + path with `jit=True` and `jit=False`. Require actual JIT only on a known-capable + wasm build; retain ordinary fallback tests elsewhere. +- [x] Cover NumPy `int64` and `uint64` arrays containing values above `2^53` so a + JavaScript-number transport regression cannot pass accidentally. +- [x] Exercise C-contiguous arrays, masks, scalar captures accepted by the first + slice, branches and loops through real Python/Cython dispatch. +- [x] Confirm unsupported reductions, math calls, checked conversions and ND + features use the interpreter and preserve Python-visible diagnostics. +- [x] Build and reinstall a fresh Pyodide wheel using the repository wasm skill. + Verify that both `blosc2` and its extension come from that wheel/runtime. +- [x] Run focused tests first, then the available wasm test suite with deterministic + single-thread settings. Record Pyodide, Emscripten, browser/Node and MiniCC + revisions in qualification results. + +## Task G: typed bridge ABI follow-up + +Do not begin this phase until bridge-free exact-i64 execution is qualified. The +preferred design is direct wasm imports with declared signatures, not function +pointers recovered from `inputs[]` and called through C casts. + +- [ ] Define a versioned bridge manifest shared by C and JavaScript. Each import + records module/name and exact wasm signature. +- [ ] Introduce bridges incrementally, beginning with one operation whose complete + semantic behavior is easy to test. Candidate signatures include: + - checked operation: `i64 (i32 node, i64 a, i64 b, i64 c, i32 status)`; + - float64 unary math: `f64 (i32 node, f64 x)`; + - comparison: `i32 (i32 node, f64 x, f64 y)`. +- [ ] Never pass an imported/exported `i64` through JavaScript without WebAssembly + BigInt integration and explicit runtime support. Prefer wasm-to-wasm table/import + calls or memory-based request/response records where portability requires it. +- [ ] Validate import signatures before instantiation and reject modules with an + ABI revision mismatch. +- [ ] Preserve lazy participation and immediate status checks: a failing left + operand must prevent evaluation of inactive right operands. +- [ ] Add one bridge family at a time with interpreter differential tests, edge + vectors, masks and fallback tests. Do not enable all existing counters together. +- [ ] Address reductions, ND context and scratch locals only after their memory ABI + is independently specified and tested. + +## Benchmark and decision gate + +Correctness qualification precedes performance claims. Once the first slice is +stable, add a wasm-specific benchmark that records separately: + +1. typed source generation; +2. TCC compilation and wasm file emission; +3. `WebAssembly.Module` compilation; +4. `WebAssembly.Instance` creation and function-table registration; +5. first kernel execution; +6. warmed execution and cache hits; +7. interpreter execution for the same workload. + +Use arithmetic, branch, loop and masked workloads at small, medium and large lane +counts. Include one-shot and repeated calls, report the reuse break-even count, +and compare values before reporting timings. Record Node/browser, Pyodide, +Emscripten, MiniCC, CPU and memory settings. Do not infer wasm performance from +native TCC measurements. + +Proceed to typed bridges only if bridge-free warm execution yields a useful gain +for representative workloads and compile/instantiation cost can be amortized by +the intended reuse pattern. Expensive math calls need a separate decision because +interpreter dispatch may be a smaller fraction of their total cost. + +## Validation sequence + +1. Host unit tests for source-kind dispatch, eligibility and generated source. +2. Existing full native miniexpr JIT/parity tests to detect host regressions. +3. Emscripten main-module native test with required actual JIT execution. +4. Emscripten side-module test using `me_jit_glue.js`. +5. Exact-i64 boundary and masking differential corpus under Node. +6. Fresh Python-Blosc2 Pyodide wheel and focused public-API tests. +7. Available wasm test suite, then benchmark qualification in at least Node and + one browser runtime. + +Use the `blosc2` conda environment for native Python/build checks in this checkout. +Use the documented Pyodide environment for actual wasm execution; native tests +cannot qualify the wasm ABI. + +## Completion criteria for the wasm32 first slice + +- At least one float kernel and exact signed/unsigned 64-bit arithmetic kernels + report and execute an actual wasm JIT kernel through main- and side-module paths. +- No portable wasm source passes through the legacy 64-to-32-bit rewrite. +- Values outside JavaScript's exact integer range round-trip and compute correctly. +- Masks and lazy control flow preserve participation semantics. +- Every unsupported bridge/reduction/ND case demonstrably falls back to the + interpreter with unchanged results and diagnostics. +- Module imports and the exported entry signature are validated before execution. +- Cache eviction, helper removal and compilation failure release all owned state. +- Existing native host JIT tests and legacy wasm JIT tests remain passing. +- Qualification records distinguish compilation, instantiation, first-call and + warmed timings and identify tested runtime versions. + +## Execution record (2026-10-18) + +Implemented in the sibling `miniexpr` checkout: + +- Portable Menudet wasm source is explicitly tagged and bypasses the legacy + 64-to-32-bit source rewrite. Its local preamble defines and compile-time checks + wasm32 fixed-width and pointer widths; portable cache keys include source kind + and a wasm ABI revision. +- The exported kernel count is `int` (wasm `i32`), with negative counts rejected; + exact-width input/output values stay in wasm memory. Only zero-bridge, + non-scalar, non-ND portable elementwise kernels are admitted. Other kernels + continue through the interpreter. +- Portable modules pass no host bridge lookup and are rejected unless imports are + their shared `env.memory` or the audited wasm32 `env.memset` primitive. The TCC + output path is unique per live TCC state and cleaned on success and error paths. +- `tests/test_dsl_jit_portable_wasm32.c` requires actual JIT for signed/unsigned + 64-bit arithmetic and float masking, checks values above `2^53`, verifies an + unsupported math kernel falls back, and runs a same-workload interpreter/JIT + timing comparison. + +Validation on the local Emscripten SDK with Node.js: + +- Environment: Emscripten 5.0.0, Node.js v26.10.0, wasm32 main-module and + side-module configurations on the local macOS host. + +- Main-module and side-module CMake builds and focused CTest both pass. The test + executes `int64`/`uint64` modular addition, mixed mask lanes, and fallback. +- Native `portable_jit_parity --require-jit --compact` passes all listed cases. +- Initial measurements exposed two generated-code problems: private lane loops + retained an `int64_t` induction variable despite the wasm32 `i32` entry count, + and every arithmetic temporary emitted an impossible `pj_status` return branch + even though first-slice eligibility proves all status-producing bridges absent. + Using an `int` lane index/count in private wasm helpers and omitting those dead + wasm-only branches reduced affine JIT time from about 6.2 to 2.8 ms/call. +- After those changes, 1,048,576 float64 lanes of `x * 1.25 + y * 0.75` over 24 + warmed calls took about 3.3 ms/call in the interpreter and 2.6 ms/call under + TCC JIT (**about 1.3x speedup**) after also removing the same provably-dead + status checks after local assignment and output store. An eight-term arithmetic + expression improved substantially but remained slower (about 6.6 ms interpreter, + 7.5 ms JIT). +- Repeating the optimized affine kernel with 10,485,760 lanes and six warmed + calls gave about 34 ms/call interpreter versus 26 ms/call TCC JIT + (**about 1.3x speedup**). Cold compile plus module instantiation took about + 2.7–5.0 ms depending on cache/order, so it amortizes in roughly one large call. +- Manually factoring the repeated product in the eight-term case (`p = x*y`, then + adding `p` eight times) reduced JIT time from about 7.5 to 5.6 ms. This suggests + a JIT-only common-subexpression pass for pure bridge-free subtrees as the next + targeted optimization. The corresponding interpreter source uses scalar local + evaluation, so its 85 ms time is not an apples-to-apples performance baseline; + compare the factored JIT to the original expression's 6.6 ms interpreter time. +- A separate `-msimd128` Emscripten build confirmed LLVM vectorizes the portable + batch primitives at 4 float32 or 2 float64 lanes (and 16/8/4/2 integer lanes). + In Node, SIMD improved the interpreter to about 3.03 ms for affine and 5.28 ms + for the eight-term expression. The scalar TCC kernels remained about 2.62 and + 7.36 ms respectively, so affine still gained 1.16x, while the unfactored + arithmetic-heavy case fell to 0.72x. The bounded loop retained about a 2.22x + JIT gain because it does not use the interpreter's straight-line batch path. +- For a bounded 16-iteration loop over the same 1,048,576 lanes, interpreter was + about 556–562 ms/call and TCC JIT about 232–243 ms/call (**2.3–2.4x speedup**). + Compile plus instantiation was about 3.5 ms, and full output buffers matched byte-for-byte. + A float-comparison branch candidate was not wasm-eligible and correctly used the + interpreter. These are local Node measurements, not browser or Pyodide results. + +Gates at this checkpoint (resolved by the final qualification below): + +- The subsequent cross-platform optimization adds conservative structural CSE for + pure arithmetic subtrees over immutable array inputs/constants, scoped to one + expression tree, and makes `PJ_STATUS_CHECK()` a no-op when typed lowering has + registered no status-producing bridge. The latter is target-neutral; wasm's + 32-bit lane counter remains target-specific. On Node, the eight-term repeated + product improved from 7.53 to 4.70 ms/call (interpreter 6.60 ms, **1.40x JIT**). +- The same benchmark now runs natively on this Apple Silicon host. One isolated + macOS/arm64 run measured affine at 2.94 ms interpreter / 1.77 ms JIT (**1.66x**), + while the corresponding wasm32 run measured 3.35 / 2.64 ms (**1.27x**). For the + eight-term expression, macOS measured 4.01 / 4.72 ms (**0.85x**), while wasm32 + measured 6.60 / 4.70 ms (**1.40x**). The native system interpreter path is + already very fast; TCC remains slower on that expression even after CSE. These + are directional local timings, not a controlled cross-machine comparison: + Node's wasm engine and native TCC have different compile/runtime paths. +- The explicit factored-source control (`p = x*y`) intentionally remains as a + benchmark: its interpreter path becomes scalar and is not comparable to the + original vector-batch interpreter. All benchmark cases compare full output + buffers byte-for-byte before reporting times. +- Acceleration remains workload-dependent: affine and bounded-loop cases benefit + on both paths; repeated arithmetic now benefits on wasm, but remains slower + under native TCC. Float-comparison branches remain ineligible on wasm. Keep typed + bridge families deferred pending broader data-type and browser/Pyodide + qualification. +- Python-Blosc2/Pyodide integration and a fresh Pyodide wheel were not run at the + time of the original record; they were completed in the final qualification + pass described below. +- The original wasm test matrix was a smoke/differential set. It was expanded to + the boundary, masking, lifecycle, eviction, fallback and browser matrix below. + +## Final first-slice qualification (2026-10-18) + +`tests/test_dsl_jit_portable_wasm32.c` now runs one differential harness that +prepares every source twice (`jit=False`, `jit=True`) and compares outputs, +including masked lanes. On Emscripten it also asserts the expected route. + +Covered in wasm main-module, wasm side-module, and the browser-compatible target: + +- signed/unsigned 64-bit `+`, `-`, `*`, unary `-`, shifts, bitwise ops and + comparisons with `INT64_MIN/MAX`, `INT32_MIN/MAX`, `2^32`, `2^53±1`, `2^63`, + `UINT64_MAX`, `-1` and `0`; +- float32/float64 `+`, `-`, `*`, `/`, comparisons, signed zero, subnormals, + infinities and NaNs; +- lazy `where`, nested and deep `where` chains, `if`/`elif`/`else`, bounded + `for`, `while`, and inline integer floor division; +- mixed/all-active/all-inactive masks, including a zero-divisor lane that must + not participate; +- zero, one, odd, tile-boundary and 4096-lane lengths; +- process-cache eviction with 70 unique kernels, repeated reuse, forced wasm + instantiation failure, compile-time width checks, negative/overflow binding + limits, undersized output/input/mask capacities, overlapping storage, and + side-module helper unregistration. + +A wasm-only defect surfaced and was fixed: `pj_expr` allocated an ~18 KB CSE +table on the wasm stack for each nested lazy expression, so nested `where` +silently exhausted the default stack and fell back to the interpreter. The CSE +table is now heap-allocated and its entry payload reduced; nested/deep `where` +now report an actual JIT kernel. This also lowers stack pressure for all wasm +lowering. + +`test_dsl_jit_portable_wasm32_browser` is built with `-sSINGLE_FILE=1` and no +Node raw filesystem. It passes under Node and under headless Chromium for both +main-module and side-module builds, exercising TCC output, module validation, +instantiation and the same differential corpus in a real browser engine. + +### Python-Blosc2 / Pyodide + +A fresh wheel was built from the local `miniexpr` checkout at +`187707088ae3f9b5e5ff28a03a9fbfc8797b376d` with Pyodide 314.0.7 / Emscripten +5.0.3, installed into a Pyodide venv, and exercised through `@blosc2.menudet` +and `PortableKernel`. `CMakeLists.txt` now pins this exact revision: + +- `tests/test_menudet_wasm.py` passes 11 tests covering exact `int64`/`uint64` + above `2^53`, affine/branch/nested-`where`/bounded-loop kernels, masks via + `evaluate_block`, tile sizes 1/3/17/1024, repeated reuse, decorator + `require_jit=True`, and interpreter fallback for math/predicate/cast/ + mixed-comparison/reduction kernels. +- `blosc2._WASM_MINIEXPR_ENABLED` is true and `PortableKernel.has_jit` reports + actual kernels, not merely interpreter parity. + +Warm Pyodide timings for 1,048,576 float64 lanes (10 calls): + +| Kernel | Interpreter | TCC JIT | Speedup | Cold JIT setup | +|---|---:|---:|---:|---:| +| Affine | 3.34 ms | 1.73 ms | 1.93x | 6.4 ms | +| Eight-term product | 4.99 ms | 2.09 ms | 2.39x | 1.7 ms | +| 16-iteration loop | 47.54 ms | 2.31 ms | 20.59x | 1.7 ms | +| Branch | 62.45 ms | 1.87 ms | 33.47x | 1.8 ms | + +### Differences from the original plan + +- The zero-copy contiguous `me_artifact_eval_ex` ABI requires naturally aligned + input/output storage and rejects offset pointers as binding errors. This is not + a user-facing Python limitation: `PortableKernel` copies/normalizes inputs with + C-contiguous aligned buffers, and the array-view adapter supports offset, + stepped, transposed and reversed views with bounded tile gathering. An + unaligned NumPy `float64` view (address `% 8 == 1`) was verified through both + interpreter and JIT Python paths. The wasm test's negative case covers only the + contiguous fast ABI; unaligned pointers are never passed to generated typed + loads. +- The side-module helper ABI does not carry the test-only + `ME_WASM_JIT_TEST_FORCE_INVALID` flag. Main-module builds corrupt the module to + exercise validation failure; side-module builds register a deliberately + rejecting instantiate helper and verify cleanup/interpreter fallback, then + restore the real helper. Helper unregistration is tested separately. +- Concurrent compilation is not applicable to this single-threaded build: the + wasm output does not enable pthreads or shared memory. The process cache is + still exercised through eviction and repeated reuse. +- Several operations originally expected to need bridges are lowered inline on + wasm: ordinary float comparisons, literal shifts, integer floor division and + nested lazy `where`. They now run through the bridge-free JIT. Math functions, + predicates, checked float-to-integer casts, mixed signed/unsigned comparisons + and reductions remain interpreter fallbacks. +- Pyodide tests run in the Pyodide venv under Node. Browser qualification uses + the Emscripten wasm test directly; Pyodide hosted in a browser was not run. +- Floating-point status flags are not observable on wasm (`supported=0`), so + qualification compares values and bit patterns (NaN category where payloads + may differ) rather than IEEE flag parity. + +Remaining work is the deferred Task G typed-bridge ABI, plus optional +browser-hosted Pyodide and wider workload/dtype/performance sweeps. No +first-slice correctness or lifecycle blocker remains. + +## Non-goals + +- Enabling SLEEF, Accelerate, relaxed floating point, SIMD, threads, or every math + operation on wasm32. +- Replacing the Menudet interpreter or removing best-effort fallback. +- Passing exact integers through JavaScript `Number`. +- Treating native TCC speed as evidence of wasm32 speed. +- Broadening portable semantics, changing NumPy compatibility, or changing the + public meaning of `jit=True`. diff --git a/plans/evaluate-numpy-parity.md b/plans/evaluate-numpy-parity.md new file mode 100644 index 000000000..ca1c7058e --- /dev/null +++ b/plans/evaluate-numpy-parity.md @@ -0,0 +1,163 @@ +# NumPy-input / explicit-NumPy-output evaluate parity + +Current implementation status: the later `improved-miniexpr` work removes +NumExpr's runtime role and adds native strided destinations, host executors and +safe promoted-integer parallelism. See +[miniexpr-implementation-results.md](miniexpr-implementation-results.md) for +current results and the significant interpreter-only performance limitation. +The initial timings and NumExpr-backed fallback notes below are historical. + +Scope: compare the public `numexpr.evaluate()` and `blosc2.evaluate()` APIs with +resident NumPy operands and an explicit NumPy `out`. No compression or fresh +full-result allocation is intentionally included in the performance comparison. + +## Functional audit + +Initial exploratory audit: 72 cases, including NumExpr's elementwise function +families, complex and byte-string operations, reductions, constant expressions, +broadcasting, reversed inputs, strided/Fortran destinations, and API options. +After the fixes, 70 cases agree and two reject the same prohibited output casts. +This is sampled API coverage, **not** exhaustive dtype/backend equivalence. + +| Previously missing/broken behavior | Change | +| --- | --- | +| `copy(x)` | Preserve operand shape; dispatch NumPy receivers to NumPy; native adapter elides the value-copy node while retaining destination writes. | +| `fmod(x, y)` | Admit the approved elementwise function and its shape/arity contract. | +| Top-level `where(condition, x, y)` | Use NumPy for synthetic NumPy metadata operands; admit the native three-argument selection. | +| `complex(real, imag)` | Approved broadcasting array constructor; assign components separately to preserve infinities. | +| `sum`, `prod`, `min`, `max` into scalar `out` | Use ellipsis assignment instead of indexing a 0-D destination with `[:]`. | +| Constant-only expressions | Admit approved parsed graphs without operand names. | +| `casting="no"` / `"safe"` | Check the result dtype before destination writes, rather than silently performing a narrowing assignment. | + +Representative regressions are in `tests/test_evaluate_numpy_compat.py`. +The existing recipe-cache tests now allow explicit destinations, which are +rebound per invocation and never retained by the cache. + +Validation: 809 focused dispatch/API/storage tests plus 1,576 additional native, +lifetime, resident-execution and ndarray expression regressions passed (2,385 +total); Ruff lint/formatting and whitespace checks passed. + +## Dispatch/performance changes + +### Follow-up: output identity, layout and keyword audit + +- Empty explicit NumPy destinations now retain their identity, including shapes + such as `(2, 0, 3)`. Evaluation still runs its normal validation path. +- Newly allocated results honor `order="F"`, `"A"` and `"K"`, including the + default `"K"` with Fortran inputs. Elementwise allocation uses NumPy's broadcast + iterator to choose layout, including permuted axes, without reading input data. + Explicit destinations keep their existing layout. Invalid orders are rejected. +- `order` is consumed by Blosc2 rather than forwarded to NumExpr. Explicit C + order retains native-first admission. Resident non-C-contiguous destinations + use the approved NumPy graph fallback, followed by `np.copyto`; layout alone + does not select NumExpr. This can allocate full-size intermediates and remains + a performance opportunity for native strided-output support. Compressed/mixed + fallback migration remains part of the removal plan. +- Probed `optimization="moderate"`/`"aggressive"`, `truediv=True`, + `sanitize=True` and `disable_cache=True` in safe/full modes with fresh and + supplied outputs. Invalid optimization and unknown keywords were rejected. + These explicit options decline automatic native-first dispatch and reach the + compatibility backend; accepting them does not mean native support. +- A regression test verifies that `disable_cache=True` rebuilds resident + compatibility preparation on each call and populates neither the evaluate + recipe cache nor the resident NumExpr program cache. This does not promise + removal of parser caches or every lower-level library cache. +- `prepare_evaluate()` now provides an immutable operand-free evaluator with + explicit per-call bindings, output rebinding, option overrides and lazy + signature preparation. It reuses the existing bounded preparation caches; + there is no global last-expression state. See the expression utilities docs. +- `re_evaluate()` additionally offers thread-local last-expression convenience + after a successful public `evaluate()`. It rebinds operands from explicit + dictionaries or caller scope, reuses only a still-live explicit output through + a weak reference, and retains validation. Failed/nested evaluations and explicit + prepared calls do not overwrite the saved expression. This is not a claim of + matching NumExpr's unchecked-loop performance. +- Public option validation is now backend-independent, including invalid options + on NumPy strided-output paths. Optimization is a backend request, not a promise + of identical algebraic rewrites. Cache bypass scope and sanitize policy are + documented explicitly. +- Overlapping NumPy operands are snapshotted before destination writes. Empty + resident reductions use NumPy identities/errors, including axis reductions. + This fixes empty sums/products incorrectly returning empty arrays and shifted + copy destinations overwriting unread inputs. + +### Initial parity improvements + +- Fix native text ingestion's reduction flag: a root call is not necessarily a + reduction. Previously `sqrt`, `hypot`, `fmod`, and `where` were misclassified. +- Extend the conservative lane-local floating-function admission list, including + `log1p`, `expm1`, rounding, predicates and binary math. Previously several large + arrays unnecessarily ran serially. +- Permit eligible resident reductions with explicit NumPy output, retaining the + existing native parallel-reduction machinery. +- Reuse operand-free preparation recipes for reviewed math calls and explicit + destinations, not just basic arithmetic and newly allocated outputs. +- For resident expressions that already need the optional NumExpr compatibility + backend (notably complex construction), write directly into `out` instead of + producing chunk temporaries. Cache unbound programs, with a per-program lock; + neither operand nor destination arrays are retained. Execution failures are + propagated without fallback/replay. This is **not a native performance win**. + +Experiments lowering the Python-worker threshold and using a private prefilter +scheduler for small arrays did not reach parity. They are not retained; there is +no new scheduler, persistent native context or extension change in this patch. + +## Reproduction + +Use the `blosc2` conda environment and an extension matching this checkout: + +```sh +conda run -n blosc2 python bench/evaluate-numpy-parity.py --threads 8 --samples 7 --json parity.json +conda run -n blosc2 python bench/evaluate-numpy-parity.py --dtype float32 --threads 8 +conda run -n blosc2 python bench/evaluate-numpy-parity.py --dtype int64 --threads 8 +``` + +The script qualifies output identity and numerical agreement before timing, +warms one shared destination, randomizes engine order, and reports medians. +Integer/bool comparisons are exact; floating/complex comparisons use explicit +tolerances. Unsupported or non-equivalent cases remain `N/A`, not timings. +Route instrumentation is outside the timed section. `numexpr-fallback` results +must not be presented as native parity. Compilation/warmup are excluded, while +public API preparation/rebinding is included on every timed call. + +## Local measurements and remaining work + +M4 Pro, eight threads, 8M float64 elements, seven timed samples, JIT `cc`: + +| Expression | NumExpr ms | Blosc2 ms | Route | +| --- | ---: | ---: | --- | +| Linear arithmetic | 1.162 | 1.229 | native | +| Polynomial | 1.569 | 1.215 | native | +| Division | 1.101 | 1.209 | native | +| Power | 4.866 | 5.109 | native | +| Square-root norm | 1.489 | 1.181 | native | +| Sine + cosine | 3.794 | 4.264 | native | +| `log1p + expm1` | 4.667 | 4.531 | native | +| `hypot` | 1.299 | 1.424 | native | +| `fmod` | 3.465 | 3.712 | native | +| Rounding | 2.207 | 1.677 | native | +| Predicate | 1.469 | 1.116 | native | +| Selection | 1.387 | 1.232 | native | +| Copy | 0.802 | 0.738 | native | +| Sum of products | 6.247 | 1.293 | native | +| Complex construction | 1.407 | 1.476 | NumExpr compatibility | + +The first baseline had `log1p + expm1` at approximately 37 ms; correcting +parallel admission removes most of that gap. Measurements are local warm runs, +not cross-platform guarantees; small cases are particularly sensitive to noise. + +**Parity is not complete:** + +- At 100k elements, serial native transcendental evaluation and Python dispatch + still lose to NumExpr's worker scheduling (roughly 3–4x for some math recipes). +- Several float64 8M cases remain about 5–12% slower. +- Large int64 arithmetic/copy/reduction cases are competitive, but integer-input + math returning floats still often misses conservative parallel admission and + is about 5–7x slower. Do not simply broaden integer lane-local admission: + checked conversions and integer error-domain semantics must remain intact. +- Large float32 sums fail the strict cross-engine numerical qualification + (different accumulation/order behavior). Integer powers with overflow also + fail agreement; NumExpr rejects integer complex construction. These remain + `N/A`; no tolerance was relaxed to produce a performance comparison. +- This audit does not redefine Blosc2's NumPy-style dtype promotion to match + NumExpr's different promotion rules. diff --git a/plans/flexible-mathlib-support.md b/plans/flexible-mathlib-support.md new file mode 100644 index 000000000..dde132253 --- /dev/null +++ b/plans/flexible-mathlib-support.md @@ -0,0 +1,369 @@ +# Flexible math libraries and floating-point modes for Menudet + +Status: implemented 2026-10-18 (flexible source/env math selection, artifact +policy, per-kernel dispatch, interpreter/vector and CC/TCC integration). +Numerical qualification probes and reports predate this integration; see +[integrated performance results](mathlib-performance.md) for a measurement that +does not imply numerical certification. + +## Objective and scope + +Allow Menudet kernels to select system math, SLEEF or Apple Accelerate explicitly, +independently of compiler floating-point optimizations. Preserve the current +system-math behavior by default. Give the legacy SIMD path the same environment +selection policy while it remains supported, rather than maintaining conflicting +meanings ahead of its eventual removal. + +Implement the policy in native miniexpr, then integrate its artifacts and Python +bindings in Python-Blosc2. Native numerical semantics and backend matrices belong +in miniexpr tests. Python tests should cover authoring, serialization, errors, +dispatch, scheduling and representative end-to-end execution. + +Out of scope: removing legacy SIMD now; adding new mathematical operations; +general numerical repair wrappers around third-party libraries; wasm32 TCC JIT; +new dependencies beyond existing optional SLEEF/Accelerate support. The wasm32 +JIT investigation is tracked separately in +[todo/enable-tcc-menudet-wams32.md](../todo/enable-tcc-menudet-wams32.md). + +## Agreed user-visible behavior + +### Math selection + +| Effective selection | Behavior | +| --- | --- | +| `auto` | System math with Menudet's existing operation definitions. No automatic SLEEF/Accelerate preference. | +| `system` | Explicit system-math policy. This does not disable JIT or safe execution optimizations. | +| `scalar` | Retain the existing environment spelling for forced system scalar math. | +| `sleef` | Explicit SLEEF selection; default accuracy u35, optionally u10. | +| `accelerate` | Explicit Accelerate selection on supported macOS builds. | + +`ME_SIMD_MATH_BACKEND` remains the environment selector. Add `system` as an +accepted value and change legacy `auto` to the same system policy as Menudet. +Keep `scalar` as its existing explicit scalar option; the source pragma need +not add a duplicate spelling. Do not rename the environment variable in this +effort, despite its historical SIMD-specific name. + +An available accelerated backend may use documented system fallbacks for +operations it does not implement. Backend availability and operation coverage +are different checks. Do not silently replace an explicitly requested library +with another library when that backend itself is unavailable. + +### Source pragmas + +Follow the existing header-pragmas convention: + +```python +# me:compiler=cc +# me:fp=fast +# me:math=sleef +# me:ulp=u35 +def kernel(x): + return sin(x) + cos(x) +``` + +- `me:math=auto|system|sleef|accelerate`. +- `me:ulp=u10|u35`, optional; SLEEF defaults to u35. +- Existing `me:compiler=tcc|cc` remains independent. +- Enable `me:fp=strict|contract|fast` for Menudet as described below. +- Reject unknown values, duplicate keys and malformed directives consistently + with existing pragma parsing. Preserve source locations in errors. +- Validate `me:ulp` against the resolved math backend. It is meaningful only + for SLEEF; reject it when the effective backend is not SLEEF instead of + silently ignoring it. With no math tag, an environment-selected SLEEF backend + may supply that effective selection. + +### Precedence and resolution lifetime + +For each setting: explicit source pragma, then applicable environment setting, +then built-in default. Preserve an explicit-presence bit rather than inferring +presence from a parsed enum's default value. + +- No math tag: inherit `ME_SIMD_MATH_BACKEND`, or `auto` if unset. +- Explicit `me:math=auto`: select the defined system policy; do not consult the + environment for math selection. +- Explicit `me:math=system` overrides an environment request for Accelerate, + including on a platform where Accelerate is unavailable. +- Explicit `me:fp` overrides `ME_DSL_FP_MODE`; absent either, use strict. +- Preserve the existing compiler source-over-environment precedence. +- Do not introduce a new environment variable solely for SLEEF accuracy in + this work. Reuse existing native per-call accuracy controls where applicable; + source accuracy must be respected consistently rather than bypassed by them. + +Resolve defaults once per prepared kernel, before first execution, and retain +an immutable effective policy for its lifetime. Reading process environment +variables inside worker loops is neither necessary nor safe. Different prepared +kernels must coexist with different explicit policies in one process. + +### Floating-point modes + +| Mode | CC flags / permission | Compatibility | +| --- | --- | --- | +| `strict` | `-fno-fast-math -ffp-contract=off` | Default compiler behavior, current operation semantics. | +| `contract` | `-fno-fast-math -ffp-contract=fast` | Permit FMA contraction and resulting rounding/status differences. | +| `fast` | `-ffast-math` | Permit broader transformations; strict NaN/infinity/zero/rounding/status compatibility is waived. | + +Math-library choice and FP mode are independent. In particular, strict plus +SLEEF/Accelerate is permitted: strict constrains generated arithmetic, but does +not upgrade the selected library's documented values, domains or exceptions. +Fast plus system math and fast plus SLEEF/Accelerate are also valid. + +Native TCC currently supports strict only. Explicit TCC plus contract/fast must +give a clear unsupported-combination error, not silently execute as strict. +Optional interpreter execution may retain ordinary arithmetic under relaxed FP +policy: relaxation grants optimization permission rather than requiring a +particular changed result. Required-JIT and explicit unsupported-compiler +requests must retain clear failure behavior; do not hide them with fallback. + +### Numerical contract + +Preserve operation identity across backend selection: floor-mod remainder, +ties-even rounding and other defined Menudet operations must not accidentally +become a same-named C function with a different definition. Review pi functions +and min/max separately, using existing semantic helpers where appropriate. +Under fast FP, the user separately accepts compiler-level numerical relaxation; +do not claim strict signed-zero/NaN behavior for optimized generated arithmetic. + +For explicitly selected SLEEF/Accelerate functions, accept their documented +accuracy, domain restrictions and exception behavior. Do not construct a broad +adapter to repair every backend result, signed zero or floating exception flag. +Changing u35 to u10 improves selected approximation bounds, not these contracts. + +Document exception reporting honestly: caller environment isolation/preservation +remains required, but NumPy-equivalent status from relaxed math libraries or +fast arithmetic is not guaranteed. Keep integer semantics, types, bounds, +mask participation and memory safety independent of numerical relaxation. + +### Platform and failure policy + +- `auto`/`system`: available on Linux, macOS, Windows and wasm32; wasm32 uses + the runtime/toolchain math implementation. +- `sleef`: require both a supported compiled implementation and target CPU + capability. Do not assume availability merely from an OS name. Current native + dispatch includes AVX2 and ARM Advanced SIMD; wasm32 support is not established. +- `accelerate`: require macOS and an Accelerate-enabled build. +- Unavailable effective explicit backend requests from source or environment + fail during preparation, before evaluating any data. Report backend, platform + and supported alternatives. Validate malformed effective environment settings + rather than silently treating misspellings as auto. +- Individual documented system fallbacks within an available backend remain + valid. They must be visible in test/diagnostic information. + +## Current implementation and gaps + +Relevant native code in the sibling miniexpr checkout: + +- `src/dsl_parser.c`: currently understands only `me:fp` and `me:compiler`. +- `src/dsl_compile.c`: typed portable profiles explicitly reject non-strict FP. +- `src/dsl_portable_expr.c`: system callbacks and Menudet semantic operations. +- `src/dsl_portable_batch.c`: bounded vector interpretation, currently strict. +- `src/dsl_portable_jit.c`: typed generated kernels and strict host bridges; + wasm32 source generation is explicitly declined for ABI reasons. +- `src/functions-simd.c`: existing SLEEF/Accelerate wrappers, process-wide backend + initialization/function pointers, and thread-local scalar/accuracy overrides. +- `src/dsl_config.h` and `src/dsl_jit_backend_*.c`: existing FP flags, environment + defaults and strict-only native TCC behavior. +- `src/dsl_artifact.c`, artifact headers and JIT cache code: validated artifact + representation, capability requirements, loading, preparation and cache identity. + +Python integration: + +- `src/blosc2/dsl_kernel.py`: source retention and `DSLKernel.export()`. +- `src/blosc2/portable_kernel.py`: normalized source and artifact construction; + currently emits `semantics.fp = strict` unconditionally. +- Native/Cython bindings and build pins must expose the matching native feature + and error contracts. Locate all artifact preparation/evaluation callers before + changing any native ABI or lifecycle. + +Build configuration already enables Accelerate on macOS and dynamically links +the system framework. No Apple implementation is bundled; enabling Menudet +dispatch does not require shipping a large additional library. + +## Implementation sequence + +### 1. Define and test policy resolution in miniexpr + +Add the minimal native policy representation: requested math backend, requested +SLEEF accuracy, FP mode, explicit-presence information, and effective settings. +Reuse existing enums where their meanings fit. Separate backend availability +from operation coverage. Make one resolver authoritative for typed preparation +and legacy selection rather than duplicating precedence in Python. + +Add parser support and native unit tests for all values, duplicate/unknown +directives, omitted versus explicit auto, environment precedence and invalid +combinations. Test environment cases in isolated subprocesses where necessary. +Specify precedence of existing per-call overrides explicitly before wiring them: +they must not silently weaken an explicit kernel numerical policy. + +### 2. Persist executable policy in artifacts + +Use validated semantic/execution fields, not informational `metadata`. +Preserve explicit source choices through export, JSON round trips and native +loading; retain omitted settings as inheritance requests resolved at preparation. +Do not bake one machine's environment-derived choice into exported source. + +The current artifact schema rejects unknown fields and requires strict FP. +Extend its version/capability contract deliberately: introduce a recognized +flexible-math requirement for artifacts depending on the new policy, update +the schema specification, and require old readers to fail closed. Settle exact +wire-field names and whether a draft version increment is necessary before +coding the exporter. Do not reinterpret an existing strict claim as fast. + +Validate source directives against declared artifact policy and reject conflicts. +Keep old artifacts without new choices on their documented interpretation; +explicit legacy strict FP declarations remain strict. Document whether missing +math policy inherits the new environment default, consistent with omission rules. + +### 3. Make backend dispatch kernel-local + +Refactor only as much of `functions-simd.c` as needed to reuse its wrappers via +an immutable per-prepared-kernel table/descriptor. Do not mutate process-global +function pointers when alternating kernels. Resolve CPU/build availability once +and pass the selected callbacks through existing typed runtime bridges. + +Give legacy `auto` the new system meaning, add the system spelling, and enforce +explicit-unavailable errors. Retain the scalar setting and existing per-call +SIMD-disable/accuracy behavior where compatible with explicit kernel policy. +Keep user-visible function definitions separate from raw library entry points. + +### 4. Integrate Menudet interpretation and bounded vector execution + +Use the same resolved math selection in scalar interpretation and eligible +bounded vector interpretation. Audit scalar tails and partial masks: a SLEEF +kernel must not inadvertently change library merely because its array length +falls below SIMD width. If wrappers lack scalar SLEEF entry points, use bounded +lane packing or another minimal safe bridge; document and test any intentional +fallback instead of inheriting legacy tails unnoticed. + +Preserve typed float32 calls and signaling-NaN transport where the contract +requires it. Maintain operation semantic helpers, inactive-lane isolation, +caller fenv preservation and bounded scratch. Do not aggregate exceptions from +speculative inactive lanes as if the source evaluated them. + +### 5. Integrate TCC/CC generated kernels and relaxed FP + +Route generated calls through the same prepared callback table/bridge. Preserve +bounded tiling rather than adding full-array temporaries. Keep backend policy +valid for JIT-disabled and optional-fallback execution as well as warmed JIT. + +Remove the blanket portable non-strict rejection only after both interpreter +policy and generated-code contracts are implemented. Apply mode flags to the +generated arithmetic, not to the entire library or safety helpers. Review +generated NaN/finite checks, floating-to-integer conversions, index/bounds checks +and optimizer assumptions; move safety-critical checks behind strict helpers +where necessary. Existing strict-only generated-source guards must become +mode-aware rather than simply being deleted. + +Native TCC: implement strict math-backend bridges and reject explicit relaxed +FP requests. CC: support strict, contract and fast. Keep wasm32 on its current +interpreter path; do not imply a new wasm32 JIT capability. + +### 6. Cache and concurrency correctness + +Include effective math backend, SLEEF accuracy, FP mode, bridge ABI and relevant +implementation/version identity in JIT eligibility/cache keys and validation. +Keep system/auto normalization consistent; never reuse incompatible kernels. +Do not serialize function addresses. Re-resolve available runtime callbacks on +load. Platform-dependent artifacts fail clearly when explicit requirements +cannot be met on the destination machine. + +Exercise concurrent and interleaved kernels with different backends/modes, +thread-pool execution, cache hits and cache invalidation. Preserve the existing +serialization needed by libtcc compilation; runtime callbacks must remain +kernel-local and safe after compiler state cleanup. + +### 7. Python integration, documentation and migration + +Update exporter/bindings to preserve validated pragmas and artifact policy, and +translate native preparation errors into the existing structured error types. +Keep policy ownership native; avoid a second Python backend-selection algorithm. +Cover `DSLKernel.from_source`, decorated-source extraction, artifact export/import, +`PortableKernel`, lazy execution and evaluate-generated artifacts as applicable. + +Update native DSL syntax/usage, artifact specification and Python docs. Provide +strict-system, strict-SLEEF-u35, CC-fast-system and CC-fast-SLEEF examples. Explain +precedence, unavailable libraries, system fallback coverage and platform limits. + +Call out two legacy behavior changes: auto no longer prefers SLEEF, and an +unavailable explicit backend now errors. Existing users wanting the old SLEEF +selection can request it explicitly. Do not remove legacy evaluation in this +change. Update the native dependency pin and Python build configuration only +after the native implementation is independently qualified. + +## Validation and acceptance + +1. Native parser/resolver/artifact tests establish source-over-environment + precedence, effective choices, schema round trips and fail-closed imports. +2. Native numerical coverage distinguishes operation definitions from backend + approximation/domain/exception behavior. Reuse the existing qualification + corpus and reports; do not duplicate exhaustive matrices in Python tests. +3. Strict-system interpreter/TCC/CC preserves current supported semantics. + Explicit SLEEF/Accelerate calls demonstrably reach the chosen implementation + on full vectors, short arrays and tails. System fallback cases are identified. +4. Contract tests demonstrate a suitable FMA-sensitive example without assuming + contraction is mandatory. Fast tests verify flags/mode application and safety + invariants, rather than demanding one compiler-specific approximate result. +5. Bounds, integer arithmetic, mixed dtypes, masks, exceptions, reductions, empty + inputs and concurrency retain their non-relaxed guarantees. Explicit invalid + combinations and unavailable backends fail before execution. +6. Run the common 44-function/input audit against actual integrated Menudet paths, + covering u10/u35/Accelerate and separate FP modes. Preserve reproducible input + hashes and independent references; raw ULP-versus-system differences are not + automatically backend defects. Broaden ldexp/fma separately as appropriate. +7. Benchmark cold preparation/JIT and warm execution against current strict-system + behavior and NumExpr: arithmetic, transcendental-heavy and mixed kernels, + float32/64, small and large arrays, single/multiple threads, TCC/CC. Do not + infer performance from the numerical audit. Check scratch and binary size. +8. Qualify Linux and macOS first, Windows on its supported build/CPU configuration, + and wasm32 interpreter behavior. Unsupported SLEEF/Accelerate requests must + error on the applicable targets. A missing runner is an explicit validation + gap, not a passed platform. + +Use the `blosc2` conda environment for Python, tests and builds. Reuse incremental +native builds with the same miniexpr source override, verify loaded source and +extension paths, and use isolated packages where needed rather than replacing +another checkout's editable extension. Finish with relevant native checks, +Python binding tests and an independent wheel check. No git state-changing +operations are part of this plan without explicit user instructions. + +## Implementation outcome (2026-10-18) + +Implemented in native miniexpr and Python-Blosc2: + +- `me:math`/`me:ulp` parsing, presence bits and one resolver with source > + artifact > environment > default precedence; invalid env values fail. +- Artifact `semantics.math`/`semantics.ulp`, optional `semantics.fp`, and the + `flexible-math` capability with fail-closed old-reader behavior. +- Kernel-local immutable callback tables; legacy `auto` now means system math. +- Bounded vector interpretation uses accelerated tables over tiles; scalar + interpretation uses documented lane packing. +- `contract`/`fast` reach CC-generated kernels; TCC rejects them explicitly. + Portable artifacts with accelerated math deliberately use the bounded vector + interpreter instead of the fused per-lane JIT, whose callback bridge would pay + one lane-packing dispatch per element. +- JIT cache identity includes math backend and SLEEF accuracy. +- Python export/info/tests and documentation updated. + +Deliberate differences from this plan: accelerated math does not use generated +JIT kernels; it uses the vector interpreter fallback described above. SLEEF +accuracy is not exposed through a new environment variable (per plan). The legacy +SIMD path still uses its process-global dispatch rather than the new per-kernel +table, but its `auto`/`system` meaning and preparation-time availability errors +now agree with Menudet. + +## Existing evidence and remaining risks + +- [Shared backend audit](math-backend-shared-qualification.md) and + [raw results](math-backend-shared-qualification.json): same 44 functions, + float32/64 and input hashes across u10/u35/Accelerate configurations. +- [Broader SLEEF audit](sleef-menudet-qualification.md): documented range limits, + operation differences, flags and independent-reference checks. +- [Accelerate audit](accelerate-menudet-qualification.md): value/status behavior + and Apple's explicit exception/denormal caveats. +- [Performance exploration](math-backend-performance.md): prototype measurements, + not a qualification of integrated generated Menudet execution. + +Highest risks: global backend state leaking across kernels; scalar tails using +different semantics; old artifacts silently gaining relaxed behavior; fast-math +weakening safety checks; inappropriate exception guarantees; and unsupported +platform assumptions. The wire-format extension and compatibility tests must +be settled before enabling any new execution mode by default. diff --git a/plans/improved-miniexpr.md b/plans/improved-miniexpr.md new file mode 100644 index 000000000..b61ee120e --- /dev/null +++ b/plans/improved-miniexpr.md @@ -0,0 +1,642 @@ +# A reusable native execution layer for miniexpr + +Status: core implementation completed on the `improved-miniexpr` branches; +release qualification and remaining performance work are described below. + +## Implementation outcome + +Native changes are in `../miniexpr`: + +- `7d8d5e1`: versioned writable destinations, checked bounds/alignment/injectivity, + bounded scatter, serial reduction stores, ordinary/source-backed graph outputs, + final conversions and staged final destinations. Old contiguous APIs remain. +- `f9ea92c`: conservative native-IR partition capabilities and a synchronous host + fork/join API with task ownership, preflight, deterministic status aggregation, + workspace admission and serial fallback. +- `a3aba8c`: destination-aware axis partitioning/traversal, bounded automatic + executor tiles, and direct identity copies (including matching dense F/reversed + layouts) without interpreter or JIT kernel execution. +- `92caba9`: safe integer-input real-math/true-division partitioning, keeping + checked casts, integer division/power and scalar-only checked subtrees serial. + +Python-Blosc2 binds destination allocation bounds, including buffer-backed NumPy +arrays, and supplies a host adapter over its existing worker pool. Native graph +maps now use miniexpr's safety metadata and partitioning instead of Python AST +proofs/partitioning. Both JIT and interpreter graph dispatch are supported. +Source-backed descriptor outputs use bounded native readers. Existing fused +compression-prefilter execution remains caller-driven. + +NumExpr's runtime import, calls, program cache, thread setup and required package +dependency have been removed. The old `ne_evaluate` helper name and nullable +`blosc2.numexpr`/`lazyexpr.numexpr` attributes remain compatibility spellings only; +they do not import or select NumExpr. Comparison benchmarks still use NumExpr +as an optional external reference. See `native-execution.md` in miniexpr for the +public C contract and `miniexpr-implementation-results.md` here for qualification. + +### Deliberate limits and remaining work + +This does **not** mean every aspiration in the original plan below is complete: + +- The generic executor handles resident maps, not concurrent storage callbacks. + Existing reader contracts are serial; compression hosts retain outer ownership. +- C-Blosc2's available general-job launcher is private, not a public embedding + contract. No miniexpr dependency on that private interface was introduced. + Python-Blosc2 currently supplies the executor using its existing host pool. +- Existing automatic parallel-reduction policy and non-graph portable-DSL safety + proofs still have Python adapters. Native graph maps no longer depend on those + proofs; strict native reductions retain their serial numerical contract. +- Complex/string operations outside native numerical coverage use NumPy. +- Actual Windows execution/CI and remote exact-revision qualification are not + established by local macOS/WASM tests. No evidence gate has been relaxed. +- Most importantly, genuine interpreter-only arithmetic is much slower than + NumExpr in local measurements (approximately 30–90x for sampled 8M real maps). + The portable interpreter still evaluates scalar expression trees; a profiled + vector/bytecode execution project is needed before claiming no-JIT performance + parity. Native identity copies are fast independently of JIT. + +The functional removal and reusable C execution layer are available for evaluation. +The interpreter regression is a release decision point, not hidden behind a +NumExpr fallback or a claim that all performance exit gates have passed. + +## 1. Objective + +Make miniexpr sufficiently capable and flexible to serve independent C projects +and bindings for multiple languages. Move numerical execution machinery out of +Python-Blosc2 into the native layer that owns its semantics. + +The target is more than adding strided output: provide reusable preparation, +validation, layout traversal, bounded buffering, safe work partitioning and +execution for both the interpreter and JIT. Python-Blosc2 becomes primarily an +API, object-lifetime and storage adapter. + +Related plans: + +- [remove-numexpr.md](remove-numexpr.md): removing the NumExpr runtime dependency. +- [evaluate-numpy-parity.md](evaluate-numpy-parity.md): current compatibility and + performance evidence, including resident NumPy fallback limitations. +- [menudet-performance-parity.md](menudet-performance-parity.md): existing fused + execution, storage-reader and scheduling work. + +This work enables NumExpr removal but need not block that entire project. A +native serial interpreter plus explicit NumPy fallbacks can support the removal +milestone before every scheduling optimization is migrated. + +## 2. Architectural ownership + +| Responsibility | Target owner | +| --- | --- | +| Restricted expression parsing, graph construction, dtype inference | miniexpr | +| Immutable preparation and shape specialization | miniexpr | +| Numerical semantics, checked conversions, FP diagnostics | miniexpr | +| Array bounds/layout validation, broadcasting, gather/scatter | miniexpr | +| Tiling, scratch estimates, parallel eligibility and partitioning | miniexpr | +| Interpreter/JIT selection and execution reports | miniexpr | +| Scheduling tasks onto an application's existing worker pool | Host executor adapter | +| Optional standalone worker-pool implementation | Separate optional miniexpr component, if justified | +| Compression, decompression, storage caches and persistent containers | C-Blosc2 or another storage host | +| Python object inspection, references and exception translation | Python bindings | +| Public NumPy allocation policy and unsupported NumPy operations | Python-Blosc2 | + +Do not move Python-specific APIs, NumPy objects, Blosc2 compression policy or a +particular storage format into miniexpr. Move the reusable execution rules. + +### Two supported execution models + +1. **Whole-domain execution:** the host supplies descriptors, optional readers + and an execution policy. miniexpr prepares and partitions work, then runs it + serially or through a host executor. +2. **Caller-driven block execution:** a host such as C-Blosc2 already controls + workers and block lifetimes. It invokes prepared miniexpr work for a supplied + block without creating another parallel region. + +Both models must share preparation, validation, kernels, scratch rules and +diagnostics. Caller-driven execution is essential for fused +evaluate/filter/compress behavior; it is not a legacy path to replace with +full-array materialization. + +## 3. Source assessment and existing foundations + +Paths below refer to `../miniexpr` unless prefixed with `python-blosc2`. +Line references are approximate and describe the checkout inspected for this plan. + +### Native array traversal + +`src/dsl_array.c` already contains: + +- `a_add()` / `a_valid()` (around lines 40–59): checked signed-stride arithmetic + and allocation bounds, including negative strides. +- `a_offset()` / `a_coordinates()` (around lines 83–97): logical coordinates and + byte offsets. +- `a_run()` (around line 232): shared preflight, bounded input gathering, + storage-reader calls, map evaluation and serial reduction. +- A shared `me_artifact_eval_ex()` tile invocation (around line 384). +- Scratch and input-copy reporting through `me_array_report`. + +Output handling is currently contiguous: + +- Map destination: `output + begin * source_width` when no scratch is used. +- Reduction destination: `output + group * width`. + +This is a good place to add bounded output scatter without changing every kernel. +Serial reduction output layout can change independently of accumulation order. + +### Native graph execution + +`src/dsl_graph.c:g_execute()` and `g_execute_staged()` validate raw output +pointers/capacities and assume C-order layout. The output contract must propagate +through final conversions and the final stage, while internal intermediates can +remain contiguous. + +`me_graph_execute_alias()` is a separate transactional adapter: it allocates a +full contiguous result within a staging budget and publishes it only on success. +It does not provide bounded-memory arbitrary alias handling. Preserve that +distinction rather than silently changing its guarantees. + +### Public interfaces and adapters + +- `src/miniexpr_artifact.h`: `me_array_view` already describes input allocation + bounds, offsets, shapes, signed strides and byte order. Its documented output + contract is currently disjoint, aligned C-order storage. +- `src/miniexpr_graph.h`: ordinary and storage-source execution expose a raw + output pointer/capacity. Plans and schedules have explicit ownership APIs. +- `python-blosc2/src/blosc2/dsl_graph_bridge.h`: adapts native graph APIs and + capability availability. +- `python-blosc2/src/blosc2/blosc2_ext.pyx`: graph and block output admission + currently requires writable, aligned C-contiguous destinations. +- `python-blosc2/src/blosc2/resident_execution.py`: resident worker pool, + partitioning, lane-local safety proofs and worker joining. +- `python-blosc2/src/blosc2/storage_readers.py` and `native_graph.py`: storage and + resident eligibility, scheduling heuristics and native dispatch. + +Existing native tests such as `tests/numpy-compat/arrays.c` cover input reversal, +broadcasting, bounds/overlap rejection, tile-size-independent reductions and +scratch accounting. Extend this coverage instead of reproducing its cross-products +in Python. + +## 4. Design invariants + +1. **No language-runtime dependency.** Core execution is plain C, with explicit + buffers, callbacks, status codes and ownership rules. +2. **One semantic owner.** Native metadata determines parallel safety and legal + traversal changes. Python must not maintain another AST whitelist for the + same decision after migration. +3. **Interpreter and JIT share contracts.** Lack of JIT is a backend availability + decision, not evidence that an expression is unsupported. +4. **Contiguous fast paths stay fast.** New descriptors and scatter support must + not add per-element branching to existing contiguous kernels. +5. **Bounded workspace.** Temporary memory scales with tile/workers except for + explicitly declared staged intermediates or transactional alias staging. +6. **Preflight before execution.** Validate all invocation geometry, output and + policy constraints before reading through callbacks or writing results. +7. **No replay after failure.** Execution errors never trigger another backend + or repeat reader requests as a fallback strategy. +8. **Immutable preparation, invocation-local execution state.** Concurrent calls + with independent buffers do not mutate cached plans or shared scratch. +9. **Preserve numerical domains.** Checked conversions, masks, reduction ordering + and context-sensitive recipes cannot be arbitrarily retiled or reordered. +10. **No hidden nested parallelism.** One component owns each parallel region. + +## 5. Public C API evolution + +Names in this section are conceptual; choose final names after an API review. +Prefer additive, versioned entry points and compatibility wrappers over breaking +the existing raw-pointer APIs. + +### 5.1 Writable destination descriptor + +Introduce a writable view corresponding to `me_array_view`, with: + +- Element dtype and rank/shape. +- Allocation base, accessible capacity and logical-origin byte offset. +- Signed byte strides. +- Explicit byte-order policy. +- Structure size/version and reserved fields where appropriate for ABI evolution. + +Use a mutable base pointer rather than repurposing an input's `const void *` by +casting throughout the implementation. Public output descriptors must describe +the full accessible allocation, not confuse `array.nbytes` with the byte span of +a strided view. + +First version: native-endian numeric destinations with exact result dtype and +shape. Support empty dimensions, scalar output, Fortran arrays, transposes, +stepped slices and reversals when non-overlap can be proven. Keep byte-swapped +outputs, arbitrary output casts and exotic overlapping layouts separate until +their contracts are qualified. + +Existing pointer/capacity execution APIs synthesize contiguous descriptors and +continue to preserve their behavior. + +### 5.2 Destination validation + +Reuse checked bounds arithmetic, but add output-specific rules: + +- Rank/shape/dtype must match the specialized result. +- Every reachable write must be inside the described allocation; account for + negative strides and integer/pointer overflow on 32- and 64-bit hosts. +- Require appropriate alignment in the initial API. Later unaligned-store + support can use byte copies if explicitly qualified. +- Prove distinct output elements occupy disjoint byte ranges. Input broadcasting + rules are insufficient for writable destinations. +- A practical initial proof sorts nontrivial axes by absolute stride and checks + that each axis step spans the complete footprint of faster axes. This is a + sufficient condition, not a complete test for every possible legal layout. +- Reject ambiguous layouts rather than perform unbounded overlap searches. +- Preserve conservative input/output disjointness initially; document whether + overlap tests use allocation bounds or reachable footprints. +- Validate empty outputs without executing kernels or dereferencing data. + +Wrappers still own host permissions: C cannot discover that a Python array is +read-only, so the Python binding must reject it before making the native call. + +### 5.3 Execution policy and workspace + +Define a versioned policy distinguishing: + +- Backend preference: interpreter-only, JIT-preferred, JIT-required. +- Thread/task budget and optional host executor. +- Tile/workspace budget, including aggregate parallel scratch. +- Floating status requests and existing numerical policies. +- Supported alias mode, initially disjoint only for the new bounded-output path. + +Expose metadata-only workspace estimation before execution. Clearly separate: +iterator scratch, backend scratch, staged intermediates, host storage buffers, +output storage and alias staging. An optional caller-provided workspace API is +useful for embedding, but must not permit concurrent reuse of mutable workspace. + +Avoid a single global mutable thread count or executor in the core. Policies +belong to invocations or immutable execution contexts with explicit lifetime. + +### 5.4 Reporting and capabilities + +Reports should distinguish: + +- Selected interpreter/JIT implementation and fallback/rejection reason. +- Actual worker count, tile/task counts and execution mode. +- Gathered and scattered bytes, direct-write tiles and peak temporary bytes. +- Intermediate/normalization/full-output-copy bytes. +- FP flags and availability, plus deterministic failure location where supported. + +Add fields through versioned report interfaces rather than silently changing ABI +layouts. Capability discovery lets older bindings retain a supported fallback. + +## 6. Serial strided-output implementation + +### Shared array loop + +Extend `a_run()` to receive an internal validated destination abstraction: + +1. Preserve the contiguous pointer fast path. +2. For a strided map destination, allocate one bounded contiguous output tile. +3. Evaluate the tile with the existing artifact call. +4. On successful tile evaluation, scatter values using logical coordinates and + checked destination offsets. +5. For reductions, keep the accumulator loop and logical input order unchanged; + write each completed group to its destination offset. +6. Account for output scratch and scattered bytes, including short final tiles. + +Do not scatter a failed tile. Earlier successfully completed tiles may remain +visible; ordinary execution is not transactional. Document this behavior and +preserve the stronger guarantee only for explicit transactional APIs. + +### Graph integration + +- Propagate the destination through ordinary execution and source-backed maps. +- In conversion graphs, keep conversion inputs contiguous and use the supplied + destination for the final conversion. +- In staged graphs, preserve contiguous intermediate storage and apply the user + layout only to the final stage. +- Preflight the final destination before any stage or storage read begins. +- Keep alias staging behavior separate; any new strided transactional adapter + needs its own budget and publish semantics. + +This delivers functional output flexibility for interpreter and JIT without +adding stride parameters to every generated kernel. + +## 7. Move scheduling and safety metadata into miniexpr + +### Capability analysis + +Native preparation should expose sufficient information to decide: + +- Is the operation elementwise and independent across lanes? +- Does it contain checked conversions or weak-scalar evaluation whose error + domain must be preserved? +- Does execution depend on global indices, block context, captures or masks? +- Are reductions present, and which grouping/order policies are permitted? +- Is it legal to partition, change tile size or reorder traversal axes? + +Derive these properties from native IR and numerical semantics. Start with the +same conservative admitted set as current Python proofs, then expand using native +tests. Do not interpret a generic “elementwise” label as permission to reorder +errors or perform unchecked casts. + +### Work partitioning + +miniexpr produces work descriptions with logical ranges, input/output bindings, +scratch requirements and independent status slots. Partition decisions must +remain independent of Python array objects. + +- Maps: assign disjoint logical regions after proving destination injectivity. +- Reductions: preserve existing serial semantics by default. Parallel reduction + policies require explicit compatibility with the established native contract. +- Storage readers: preserve bounded requests and callback participation rules. +- Staged graphs: respect dependencies and intermediate lifetimes; avoid treating + every stage as an independent concurrent operation. + +First parallel release can restrict layouts and graph shapes while retaining a +general serial path. Unsupported parallel execution should choose serial native +execution, not require a Python numerical fallback. + +## 8. Host executor interface + +### Recommended first model + +Provide a synchronous fork/join executor callback: miniexpr gives the host a task +count, a task-entry callback and invocation state; the host returns only after +every dispatched task has completed or been safely joined. + +Specify these details in the public header and a standalone example: + +- Executor/user-data lifetime and which thread invokes callbacks. +- Tasks may run concurrently and out of order, but each task index executes at + most once; define how undispatched tasks are reported on submission failure. +- The caller thread may participate, subject to the worker budget. +- Per-task scratch/status ownership; no shared mutable kernel buffers. +- Submission failures must join in-flight work before returning an error. +- Completed work is never replayed, and failure selection is deterministic by + logical task order rather than wall-clock completion. +- No callback may escape through a language exception or longjmp; wrappers + translate exceptions into status and retain objects until all tasks finish. +- Reentrancy and nested calls must be documented. Caller-driven block execution + disables child parallel regions to avoid deadlock and oversubscription. +- FP environment/status handling belongs to each executing worker; aggregate + native flags after joins and restore worker environments as required. + +Serial execution is the default when no executor is supplied. Add a standalone +thread-pool adapter only if embedding users need it; do not make pthreads or a +particular pool an unconditional dependency of the core. + +### Storage callback concurrency + +Existing synchronous reader APIs do not automatically promise concurrent calls. +Define reader capabilities explicitly: + +- Serial-only reader: retain serial execution or serialize its calls according + to a reviewed bounded strategy. +- Concurrent reader: host guarantees independent state or internal locking. +- Worker-local reader state: optional construction/destruction hooks if needed + for private decompression contexts. + +No reader or executor pointer survives its documented lifetime. Language wrappers +that need a runtime lock must acquire it only around their callbacks; native +compute should remain able to run without that lock. + +## 9. C-Blosc2 integration and fused compression + +Implement a C-Blosc2 executor adapter using its existing workers where the public +interfaces permit it. Audit the available worker API first; do not couple +miniexpr directly to private C-Blosc2 structs. + +Keep compression-driven execution: + +- A compression worker receives its block from C-Blosc2. +- Prepared miniexpr execution evaluates into the worker's block buffer. +- Filtering/compression proceeds immediately while data is cache-resident. +- Outer compression scheduling owns concurrency; miniexpr's block call is serial + within that worker. + +For NumPy/resident output, whole-domain miniexpr scheduling can use the host +executor. For compressed/mixed inputs, source callbacks supply bounded tiles. +Keep compressed-output byte emission in C-Blosc2: a generic output callback for +all storage formats is not needed for the first strided-buffer release. + +Choose one owner for tile/chunk partitioning at each entry point. Avoid a second +whole-domain pass, redundant decode, nested pools or full-result normalization. + +## 10. Python-Blosc2 migration + +1. Extend bridge capability checks and Cython descriptor binding. Recover the + actual owning allocation, offset and strides rather than passing only the + view's logical `nbytes`. +2. Retain references to inputs, output, executor and callback state until native + fork/join completion. Release the GIL around native work where supported. +3. Route eligible resident strided outputs to native execution; retain NumPy for + unsupported dtypes/operations and older native runtimes. +4. Replace Python AST-based parallel proofs with native capability queries. +5. Move worker partitioning, tile sizing and workspace admission into native + scheduling as each corresponding native path qualifies. +6. Remove superseded Python schedulers/helpers only after route and lifetime + tests demonstrate equivalent behavior. Avoid retaining two default schedulers. +7. Keep `order` as a binding-level allocation policy. It must not select NumExpr; + the destination descriptor conveys the resulting actual layout. +8. Preserve API-level shape/casting/read-only validation and exception types, + translating native diagnostics consistently. + +Do not promise native complex or arbitrary string support as part of this work. +Current real-numeric output support and the approved NumPy fallbacks remain +explicitly classified. + +## 11. Performance optimization after correctness + +Bounded scatter avoids full-result allocation but does not guarantee fast Fortran +output. Separate functional support from the following optimizations: + +- Detect contiguous destination inner spans and write directly into them. +- Coalesce adjacent compatible axes and avoid repeated division/modulo per lane. +- For proven lane-local maps, choose traversal order considering all input and + output strides, not only destination order. +- When inputs/output share a dense axis permutation, evaluate contiguous spans + without gather/scatter where semantic admission permits. +- Choose tile sizes from item widths, active inputs, cache behavior and the + aggregate workspace budget. +- Avoid false sharing at worker boundaries and excessive tiny tasks. +- Keep logical error reporting stable when execution order changes, or decline + reordering for recipes that cannot support that guarantee. +- Preserve reduction traversal/rounding rules; do not reorder reductions simply + because a different physical layout would be faster. + +Gather/scatter should be implemented once in the native traversal layer and used +by both interpreter and JIT. Specialized stride-aware generated kernels may be +considered later if profiling justifies their maintenance cost. + +## 12. Implementation phases and exit gates + +### Phase A — Contracts and API design + +- Audit current array/graph/block interfaces, native capability metadata and + C-Blosc2 worker integration. +- Freeze descriptor, failure, overlap, workspace and executor contracts. +- Inventory Python scheduling decisions and map each to a native owner. +- Capture current correctness, route, memory and performance baselines. + +Exit: reviewed additive API proposal and a precise first-release support table. + +### Phase B — Serial output descriptors and scatter + +- Implement writable descriptors and validation. +- Add bounded map scatter and reduction final-store addressing. +- Preserve raw-pointer API wrappers and the contiguous fast path. +- Extend ordinary/source-backed graph execution, conversions and staged finals. +- Add native tests, including interpreter/JIT variants and invalid descriptors. + +Exit: standalone C programs execute supported strided-output workloads with +bounded scratch and without Python or C-Blosc2 dependencies. + +### Phase C — Native capability and partition planning + +- Produce conservative lane-local/partitionable metadata from native IR. +- Implement metadata-only work partitioning and aggregate workspace estimation. +- Establish deterministic status/error collection and task lifetimes. +- Compare admission decisions with current Python proofs on representative cases. + +Exit: a serial test executor can run all planned tasks with equivalent results, +failure domains and memory bounds; unsupported parallel cases stay serial. + +### Phase D — Executor integration + +- Add synchronous host fork/join API and an example host executor. +- Qualify concurrent calls, submission failures, joins, reentrancy and FP state. +- Implement C-Blosc2 adapter and reader-concurrency capabilities. +- Preserve caller-driven block execution and reject/avoid nested parallelism. + +Exit: real parallel execution works in a standalone C host and C-Blosc2, including +strided destinations, without Python scheduling. + +### Phase E — Bindings and migration + +- Expose new capabilities/descriptors in Python-Blosc2's bridge and Cython layer. +- Route strided resident outputs to native execution. +- Replace Python eligibility/partitioning machinery incrementally. +- Retain bounded compressed/mixed paths and fused compression. +- Update NumExpr-removal plan with completed native capabilities. + +Exit: Python API tests prove direct destination handling, no NumExpr dependency +for migrated routes, and removal of the corresponding duplicated Python logic. + +### Phase F — Layout-aware optimization and qualification + +- Optimize spans, axis ordering and task sizing using profiles. +- Compare interpreter/JIT against NumPy and optional NumExpr references. +- Qualify platforms, memory bounds, sanitizer results and exact native revisions. +- Publish support/limitation tables and standalone integration examples. + +Exit: documented correctness and performance results, explicit remaining gaps, +and approved release/integration decision. + +Phases B and E's binding work may be integrated early for serial functionality; +the parallel machinery does not have to land before useful strided-output support. + +## 13. Verification strategy + +### Native tests + +Extend existing array and graph tests for: + +- C/F layouts, axis permutations, stepped/reversed views, scalar/empty shapes, + degenerate axes and broadcast inputs. +- Canary bytes outside the logical destination, bounds overflow, insufficient + capacity, misalignment, invalid dtype/shape and self-overlapping strides. +- Input/output overlap rejection and unchanged transactional alias guarantees. +- Tile tails, multiple tile sizes, mask participation, final conversions, + reduction result layouts and staged final outputs. +- Identical serial semantics under interpreter/JIT, including FP/error status. +- Scratch accounting and budgets independent of total map output size. +- Concurrent invocations and deterministic task failures; no writes after return. +- Serial-only/concurrent readers, failed callbacks and failed executor submission. + +Use sanitizers where supported. Keep exhaustive numeric/backend matrices in +miniexpr; do not duplicate them in Python-Blosc2. + +### Integration tests + +- Python: output identity/layout, read-only views, allocation-owner lifetimes, + rebinding, native route selection, exceptions and no fallback replay. +- C-Blosc2: compression-worker ownership, bounded decompression, mixed sources, + compression ratios/results and absence of nested parallel regions. +- Standalone C: build/install and execute with no Python/NumPy/Blosc2 runtime. +- An FFI-style example: opaque handles, descriptor construction, callback lifetime + and status translation. A full additional language binding is not required to + prove the first release's C ABI usability. + +### Platforms and builds + +Exercise Linux x86-64 and available ARM64, macOS ARM64, Windows and actual wasm32. +WASM must have a working serial/no-thread configuration. Test JIT-disabled, +available-JIT and unavailable-JIT policies explicitly. Verify 32-bit arithmetic +and avoid assuming POSIX threading or C99 complex support. + +For Python/build commands use the `blosc2` conda environment. Use persistent +isolated builds and verify package/extension paths. Native changes need their +own qualification; preserve exact-revision evidence gates and aligned native pins +when integrating into Python-Blosc2. + +## 14. Benchmarks and acceptance criteria + +Benchmark copy, arithmetic chains, predicates/selection, transcendental maps and +representative reductions. Include contiguous and mixed-layout operands with +C/F/transposed/stepped/reversed outputs, interpreter and JIT, serial and parallel. +Use small inputs, 8M elements and 100M where memory permits; retain compressed and +mixed-input cases with realistic chunk/block geometry. + +Measure separately: + +- Preparation/specialization and cold startup. +- Warm native execution and complete public API cost. +- Fresh allocation versus warmed reused destinations. +- Logical throughput, scratch, gathered/scattered bytes and full-result copies. +- Compression-driven output throughput and memory use. + +Use correctness qualification before timing, randomized engine order and repeated +samples. Report variability and actual routes; JIT disabled is not proof that a +native interpreter ran. NumExpr remains an optional external reference. + +Acceptance gates: + +- Existing C-output paths have no unexplained repeatable material slowdown; agree + on numerical thresholds after collecting stable baselines. +- Strided maps do not allocate full-output staging unless explicitly requested + by an alias/transactional contract. +- Serial native support works independently of any host executor. +- Parallel scratch respects the aggregate policy and task counts respect budget. +- Every migrated Python scheduling decision has native coverage and a clear owner. +- Supported compressed-output paths remain fused; no accidental full NumPy + materialization or nested pool appears. +- Publish residual layout-performance gaps rather than claiming universal parity. + +## 15. Risks and scope controls + +| Risk | Mitigation | +| --- | --- | +| Public ABI becomes difficult to evolve | Add versioned descriptors/APIs and keep old contiguous wrappers. | +| Safe writable-layout proof rejects unusual valid views | Document a conservative subset; broaden only with evidence. | +| Parallel scheduling changes error/reduction semantics | Native IR capability proofs and deterministic task reporting. | +| Host callback lifetimes cause use-after-free | Synchronous join contract and explicit ownership examples/tests. | +| Host pool deadlock or oversubscription | Caller-driven serial block mode and documented nesting rules. | +| Scatter is correct but slower than NumPy | Preserve fallback visibility; optimize spans/traversal after profiling. | +| Graph staging adds unexpected memory | Keep intermediate budgets separate from iterator scratch. | +| Native/Python decisions remain duplicated | Track migration ownership and remove superseded helpers per phase. | +| Project expands into unrelated features | Defer native complex/string acceleration, general alias solvers and a mandatory built-in pool. | + +## 16. Effort and review checkpoints + +Source-based rough estimate for the narrower serial strided-output feature: +3–5 engineering days for native implementation/tests plus 2–4 for bindings and +platform qualification, assuming familiarity with these repositories. This is an +estimate, not a delivery commitment. + +The broader native execution-layer migration adds API design, capability analysis, +host executor integration and ownership testing. Treat it as a multi-week staged +project; estimate Phases C–F after Phase A resolves executor and semantic scope. +Do not extrapolate a fixed deadline from the simple scatter-loop change. + +Review checkpoints: + +- [ ] Descriptor/API ownership and backward compatibility approved. +- [ ] First-release layout/alias/dtype subset approved. +- [ ] Serial native implementation and standalone example qualified. +- [ ] Partitioning/error-domain metadata approved. +- [ ] Executor and reader-concurrency contracts approved. +- [ ] C-Blosc2 fusion and Python lifetime tests passed. +- [ ] Duplicated Python scheduling removed for migrated paths. +- [ ] Platform, memory and performance evidence published. +- [ ] Remaining NumExpr-removal tasks reconciled with the new capabilities. diff --git a/plans/mathlib-performance.json b/plans/mathlib-performance.json new file mode 100644 index 000000000..ae4c0e066 --- /dev/null +++ b/plans/mathlib-performance.json @@ -0,0 +1,770 @@ +[ + { + "jit": "off", + "expression": "sin+cos", + "math": "system", + "ulp": null, + "fp": "strict", + "ns_per_item": 10.46529202722013, + "seconds": 0.02093058405444026, + "max_abs_error": 0.0, + "backend": "system", + "accuracy": "" + }, + { + "jit": "off", + "expression": "sin+cos", + "math": "system", + "ulp": null, + "fp": "fast", + "ns_per_item": 10.469874832779169, + "seconds": 0.020939749665558338, + "max_abs_error": 0.0, + "backend": "system", + "accuracy": "" + }, + { + "jit": "off", + "expression": "sin+cos", + "math": "sleef", + "ulp": "u10", + "fp": "strict", + "ns_per_item": 6.580854067578912, + "seconds": 0.013161708135157824, + "max_abs_error": 4.440892098500626e-16, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "off", + "expression": "sin+cos", + "math": "sleef", + "ulp": "u10", + "fp": "fast", + "ns_per_item": 6.610187469050288, + "seconds": 0.013220374938100576, + "max_abs_error": 4.440892098500626e-16, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "off", + "expression": "sin+cos", + "math": "sleef", + "ulp": "u35", + "fp": "strict", + "ns_per_item": 5.074437474831939, + "seconds": 0.010148874949663877, + "max_abs_error": 4.440892098500626e-16, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "off", + "expression": "sin+cos", + "math": "sleef", + "ulp": "u35", + "fp": "fast", + "ns_per_item": 5.203333683311939, + "seconds": 0.010406667366623878, + "max_abs_error": 4.440892098500626e-16, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "off", + "expression": "sin+cos", + "math": "accelerate", + "ulp": null, + "fp": "strict", + "ns_per_item": 3.601791337132454, + "seconds": 0.007203582674264908, + "max_abs_error": 4.440892098500626e-16, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "off", + "expression": "sin+cos", + "math": "accelerate", + "ulp": null, + "fp": "fast", + "ns_per_item": 3.642812604084611, + "seconds": 0.007285625208169222, + "max_abs_error": 4.440892098500626e-16, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "off", + "expression": "exp(sin)+log1p", + "math": "system", + "ulp": null, + "fp": "strict", + "ns_per_item": 10.410979157313704, + "seconds": 0.02082195831462741, + "max_abs_error": 0.0, + "backend": "system", + "accuracy": "" + }, + { + "jit": "off", + "expression": "exp(sin)+log1p", + "math": "system", + "ulp": null, + "fp": "fast", + "ns_per_item": 10.879083536565304, + "seconds": 0.021758167073130608, + "max_abs_error": 0.0, + "backend": "system", + "accuracy": "" + }, + { + "jit": "off", + "expression": "exp(sin)+log1p", + "math": "sleef", + "ulp": "u10", + "fp": "strict", + "ns_per_item": 8.692729519680142, + "seconds": 0.017385459039360285, + "max_abs_error": 8.881784197001252e-16, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "off", + "expression": "exp(sin)+log1p", + "math": "sleef", + "ulp": "u10", + "fp": "fast", + "ns_per_item": 8.69781244546175, + "seconds": 0.0173956248909235, + "max_abs_error": 8.881784197001252e-16, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "off", + "expression": "exp(sin)+log1p", + "math": "sleef", + "ulp": "u35", + "fp": "strict", + "ns_per_item": 8.24420852586627, + "seconds": 0.01648841705173254, + "max_abs_error": 1.7763568394002505e-15, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "off", + "expression": "exp(sin)+log1p", + "math": "sleef", + "ulp": "u35", + "fp": "fast", + "ns_per_item": 8.089708629995584, + "seconds": 0.01617941725999117, + "max_abs_error": 1.7763568394002505e-15, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "off", + "expression": "exp(sin)+log1p", + "math": "accelerate", + "ulp": null, + "fp": "strict", + "ns_per_item": 5.7336874306201935, + "seconds": 0.011467374861240387, + "max_abs_error": 1.7763568394002505e-15, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "off", + "expression": "exp(sin)+log1p", + "math": "accelerate", + "ulp": null, + "fp": "fast", + "ns_per_item": 5.79377100802958, + "seconds": 0.01158754201605916, + "max_abs_error": 1.7763568394002505e-15, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "off", + "expression": "trig-heavy", + "math": "system", + "ulp": null, + "fp": "strict", + "ns_per_item": 12.715666787698865, + "seconds": 0.02543133357539773, + "max_abs_error": 0.0, + "backend": "system", + "accuracy": "" + }, + { + "jit": "off", + "expression": "trig-heavy", + "math": "system", + "ulp": null, + "fp": "fast", + "ns_per_item": 12.781583471223712, + "seconds": 0.025563166942447424, + "max_abs_error": 0.0, + "backend": "system", + "accuracy": "" + }, + { + "jit": "off", + "expression": "trig-heavy", + "math": "sleef", + "ulp": "u10", + "fp": "strict", + "ns_per_item": 10.53695846349001, + "seconds": 0.02107391692698002, + "max_abs_error": 2.220446049250313e-16, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "off", + "expression": "trig-heavy", + "math": "sleef", + "ulp": "u10", + "fp": "fast", + "ns_per_item": 10.528291342779994, + "seconds": 0.021056582685559988, + "max_abs_error": 2.220446049250313e-16, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "off", + "expression": "trig-heavy", + "math": "sleef", + "ulp": "u35", + "fp": "strict", + "ns_per_item": 7.711645914241672, + "seconds": 0.015423291828483343, + "max_abs_error": 3.3306690738754696e-16, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "off", + "expression": "trig-heavy", + "math": "sleef", + "ulp": "u35", + "fp": "fast", + "ns_per_item": 7.659833412617445, + "seconds": 0.01531966682523489, + "max_abs_error": 3.3306690738754696e-16, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "off", + "expression": "trig-heavy", + "math": "accelerate", + "ulp": null, + "fp": "strict", + "ns_per_item": 5.361916497349739, + "seconds": 0.010723832994699478, + "max_abs_error": 3.3306690738754696e-16, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "off", + "expression": "trig-heavy", + "math": "accelerate", + "ulp": null, + "fp": "fast", + "ns_per_item": 5.336874863132834, + "seconds": 0.010673749726265669, + "max_abs_error": 3.3306690738754696e-16, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "off", + "expression": "sqrt-norm", + "math": "system", + "ulp": null, + "fp": "strict", + "ns_per_item": 3.38856247253716, + "seconds": 0.00677712494507432, + "max_abs_error": 0.0, + "backend": "system", + "accuracy": "" + }, + { + "jit": "off", + "expression": "sqrt-norm", + "math": "system", + "ulp": null, + "fp": "fast", + "ns_per_item": 3.383958013728261, + "seconds": 0.006767916027456522, + "max_abs_error": 0.0, + "backend": "system", + "accuracy": "" + }, + { + "jit": "off", + "expression": "sqrt-norm", + "math": "sleef", + "ulp": "u10", + "fp": "strict", + "ns_per_item": 2.843062626197934, + "seconds": 0.005686125252395868, + "max_abs_error": 0.0, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "off", + "expression": "sqrt-norm", + "math": "sleef", + "ulp": "u10", + "fp": "fast", + "ns_per_item": 2.849375130608678, + "seconds": 0.005698750261217356, + "max_abs_error": 0.0, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "off", + "expression": "sqrt-norm", + "math": "sleef", + "ulp": "u35", + "fp": "strict", + "ns_per_item": 2.8560624923557043, + "seconds": 0.005712124984711409, + "max_abs_error": 0.0, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "off", + "expression": "sqrt-norm", + "math": "sleef", + "ulp": "u35", + "fp": "fast", + "ns_per_item": 2.8681461699306965, + "seconds": 0.005736292339861393, + "max_abs_error": 0.0, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "off", + "expression": "sqrt-norm", + "math": "accelerate", + "ulp": null, + "fp": "strict", + "ns_per_item": 2.9022498056292534, + "seconds": 0.005804499611258507, + "max_abs_error": 0.0, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "off", + "expression": "sqrt-norm", + "math": "accelerate", + "ulp": null, + "fp": "fast", + "ns_per_item": 2.935208613052964, + "seconds": 0.005870417226105928, + "max_abs_error": 0.0, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "on", + "expression": "sin+cos", + "math": "system", + "ulp": null, + "fp": "strict", + "ns_per_item": 5.8690623845905066, + "seconds": 0.011738124769181013, + "max_abs_error": 0.0, + "backend": "system", + "accuracy": "" + }, + { + "jit": "on", + "expression": "sin+cos", + "math": "system", + "ulp": null, + "fp": "fast", + "ns_per_item": 5.7945833541452885, + "seconds": 0.011589166708290577, + "max_abs_error": 0.0, + "backend": "system", + "accuracy": "" + }, + { + "jit": "on", + "expression": "sin+cos", + "math": "sleef", + "ulp": "u10", + "fp": "strict", + "ns_per_item": 6.864541908726096, + "seconds": 0.013729083817452192, + "max_abs_error": 4.440892098500626e-16, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "on", + "expression": "sin+cos", + "math": "sleef", + "ulp": "u10", + "fp": "fast", + "ns_per_item": 6.850499892607331, + "seconds": 0.013700999785214663, + "max_abs_error": 4.440892098500626e-16, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "on", + "expression": "sin+cos", + "math": "sleef", + "ulp": "u35", + "fp": "strict", + "ns_per_item": 5.397896049544215, + "seconds": 0.01079579209908843, + "max_abs_error": 4.440892098500626e-16, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "on", + "expression": "sin+cos", + "math": "sleef", + "ulp": "u35", + "fp": "fast", + "ns_per_item": 5.387791432440281, + "seconds": 0.010775582864880562, + "max_abs_error": 4.440892098500626e-16, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "on", + "expression": "sin+cos", + "math": "accelerate", + "ulp": null, + "fp": "strict", + "ns_per_item": 4.09643747843802, + "seconds": 0.00819287495687604, + "max_abs_error": 4.440892098500626e-16, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "on", + "expression": "sin+cos", + "math": "accelerate", + "ulp": null, + "fp": "fast", + "ns_per_item": 4.116979660466313, + "seconds": 0.008233959320932627, + "max_abs_error": 4.440892098500626e-16, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "on", + "expression": "exp(sin)+log1p", + "math": "system", + "ulp": null, + "fp": "strict", + "ns_per_item": 8.171833353117108, + "seconds": 0.016343666706234217, + "max_abs_error": 0.0, + "backend": "system", + "accuracy": "" + }, + { + "jit": "on", + "expression": "exp(sin)+log1p", + "math": "system", + "ulp": null, + "fp": "fast", + "ns_per_item": 8.195687551051378, + "seconds": 0.016391375102102757, + "max_abs_error": 0.0, + "backend": "system", + "accuracy": "" + }, + { + "jit": "on", + "expression": "exp(sin)+log1p", + "math": "sleef", + "ulp": "u10", + "fp": "strict", + "ns_per_item": 8.66512511856854, + "seconds": 0.01733025023713708, + "max_abs_error": 8.881784197001252e-16, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "on", + "expression": "exp(sin)+log1p", + "math": "sleef", + "ulp": "u10", + "fp": "fast", + "ns_per_item": 8.805353892967105, + "seconds": 0.01761070778593421, + "max_abs_error": 8.881784197001252e-16, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "on", + "expression": "exp(sin)+log1p", + "math": "sleef", + "ulp": "u35", + "fp": "strict", + "ns_per_item": 8.070062380284071, + "seconds": 0.016140124760568142, + "max_abs_error": 1.7763568394002505e-15, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "on", + "expression": "exp(sin)+log1p", + "math": "sleef", + "ulp": "u35", + "fp": "fast", + "ns_per_item": 8.09229165315628, + "seconds": 0.01618458330631256, + "max_abs_error": 1.7763568394002505e-15, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "on", + "expression": "exp(sin)+log1p", + "math": "accelerate", + "ulp": null, + "fp": "strict", + "ns_per_item": 5.764604080468416, + "seconds": 0.011529208160936832, + "max_abs_error": 1.7763568394002505e-15, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "on", + "expression": "exp(sin)+log1p", + "math": "accelerate", + "ulp": null, + "fp": "fast", + "ns_per_item": 5.856853909790516, + "seconds": 0.011713707819581032, + "max_abs_error": 1.7763568394002505e-15, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "on", + "expression": "trig-heavy", + "math": "system", + "ulp": null, + "fp": "strict", + "ns_per_item": 7.500271080061793, + "seconds": 0.015000542160123587, + "max_abs_error": 0.0, + "backend": "system", + "accuracy": "" + }, + { + "jit": "on", + "expression": "trig-heavy", + "math": "system", + "ulp": null, + "fp": "fast", + "ns_per_item": 7.431479170918465, + "seconds": 0.01486295834183693, + "max_abs_error": 1.1102230246251565e-16, + "backend": "system", + "accuracy": "" + }, + { + "jit": "on", + "expression": "trig-heavy", + "math": "sleef", + "ulp": "u10", + "fp": "strict", + "ns_per_item": 10.749458568170667, + "seconds": 0.021498917136341333, + "max_abs_error": 2.220446049250313e-16, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "on", + "expression": "trig-heavy", + "math": "sleef", + "ulp": "u10", + "fp": "fast", + "ns_per_item": 10.63245814293623, + "seconds": 0.02126491628587246, + "max_abs_error": 2.220446049250313e-16, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "on", + "expression": "trig-heavy", + "math": "sleef", + "ulp": "u35", + "fp": "strict", + "ns_per_item": 7.683229399845004, + "seconds": 0.015366458799690008, + "max_abs_error": 3.3306690738754696e-16, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "on", + "expression": "trig-heavy", + "math": "sleef", + "ulp": "u35", + "fp": "fast", + "ns_per_item": 7.863500155508518, + "seconds": 0.015727000311017036, + "max_abs_error": 3.3306690738754696e-16, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "on", + "expression": "trig-heavy", + "math": "accelerate", + "ulp": null, + "fp": "strict", + "ns_per_item": 5.472770892083645, + "seconds": 0.01094554178416729, + "max_abs_error": 3.3306690738754696e-16, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "on", + "expression": "trig-heavy", + "math": "accelerate", + "ulp": null, + "fp": "fast", + "ns_per_item": 5.408458411693573, + "seconds": 0.010816916823387146, + "max_abs_error": 3.3306690738754696e-16, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "on", + "expression": "sqrt-norm", + "math": "system", + "ulp": null, + "fp": "strict", + "ns_per_item": 0.9485210757702589, + "seconds": 0.0018970421515405178, + "max_abs_error": 0.0, + "backend": "system", + "accuracy": "" + }, + { + "jit": "on", + "expression": "sqrt-norm", + "math": "system", + "ulp": null, + "fp": "fast", + "ns_per_item": 0.994604080915451, + "seconds": 0.001989208161830902, + "max_abs_error": 4.440892098500626e-16, + "backend": "system", + "accuracy": "" + }, + { + "jit": "on", + "expression": "sqrt-norm", + "math": "sleef", + "ulp": "u10", + "fp": "strict", + "ns_per_item": 2.9672703240066767, + "seconds": 0.005934540648013353, + "max_abs_error": 0.0, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "on", + "expression": "sqrt-norm", + "math": "sleef", + "ulp": "u10", + "fp": "fast", + "ns_per_item": 2.9597501270473003, + "seconds": 0.005919500254094601, + "max_abs_error": 0.0, + "backend": "sleef", + "accuracy": "u10" + }, + { + "jit": "on", + "expression": "sqrt-norm", + "math": "sleef", + "ulp": "u35", + "fp": "strict", + "ns_per_item": 2.9706249479204416, + "seconds": 0.005941249895840883, + "max_abs_error": 0.0, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "on", + "expression": "sqrt-norm", + "math": "sleef", + "ulp": "u35", + "fp": "fast", + "ns_per_item": 3.0208334792405367, + "seconds": 0.006041666958481073, + "max_abs_error": 0.0, + "backend": "sleef", + "accuracy": "u35" + }, + { + "jit": "on", + "expression": "sqrt-norm", + "math": "accelerate", + "ulp": null, + "fp": "strict", + "ns_per_item": 3.0081248842179775, + "seconds": 0.006016249768435955, + "max_abs_error": 0.0, + "backend": "accelerate", + "accuracy": "" + }, + { + "jit": "on", + "expression": "sqrt-norm", + "math": "accelerate", + "ulp": null, + "fp": "fast", + "ns_per_item": 2.9102705884724855, + "seconds": 0.005820541176944971, + "max_abs_error": 0.0, + "backend": "accelerate", + "accuracy": "" + } +] diff --git a/plans/mathlib-performance.md b/plans/mathlib-performance.md new file mode 100644 index 000000000..def609a7d --- /dev/null +++ b/plans/mathlib-performance.md @@ -0,0 +1,44 @@ +# Integrated Menudet math backend and FP-mode performance + +2026-10-18, local macOS arm64 (Apple M4 Pro), Python 3.14, NumPy 2.5.4, +integrated `PortableKernel` artifacts from this checkout. Warm `evaluate()` +medians, 2,000,000 float64 items, 9 samples after warmup. Values are ns/item +(lower is better). `jit=off` exercises the bounded vector interpreter; `jit=on` +requests optional JIT and therefore falls back to that interpreter for explicit +SLEEF/Accelerate backends (see below). `fast` has no effect on interpreted +arithmetic; it changes `cc`-generated kernels only. + +A post-review rebuild and rerun kept the shape and absolute level of these +results: median absolute change was 1.3% and the largest change was 9.8% on the +fastest 0.95 ns/item row, i.e. within run-to-run noise. + +## JIT off (bounded vector interpreter) + +| Expression | System strict | System fast | SLEEF u10 strict | SLEEF u10 fast | SLEEF u35 strict | SLEEF u35 fast | Accelerate strict | Accelerate fast | +| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | +| sin(x)+cos(x) | 10.47 | 10.47 | 6.58 | 6.61 | 5.07 | 5.20 | 3.60 | 3.64 | +| exp(sin(x))+log1p(x+1.5) | 10.41 | 10.88 | 8.69 | 8.70 | 8.24 | 8.09 | 5.73 | 5.79 | +| sin(x)*cos(x)+tan(0.25x) | 12.72 | 12.78 | 10.54 | 10.53 | 7.71 | 7.66 | 5.36 | 5.34 | +| sqrt(x*x+1) | 3.39 | 3.38 | 2.84 | 2.85 | 2.86 | 2.87 | 2.90 | 2.94 | + +## JIT on (optional JIT requested) + +| Expression | System strict | System fast | SLEEF u10 strict | SLEEF u10 fast | SLEEF u35 strict | SLEEF u35 fast | Accelerate strict | Accelerate fast | +| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | +| sin(x)+cos(x) | 5.87 | 5.79 | 6.86 | 6.85 | 5.40 | 5.39 | 4.10 | 4.12 | +| exp(sin(x))+log1p(x+1.5) | 8.17 | 8.20 | 8.67 | 8.81 | 8.07 | 8.09 | 5.76 | 5.86 | +| sin(x)*cos(x)+tan(0.25x) | 7.50 | 7.43 | 10.75 | 10.63 | 7.68 | 7.86 | 5.47 | 5.41 | +| sqrt(x*x+1) | 0.95 | 0.99 | 2.97 | 2.96 | 2.97 | 3.02 | 3.01 | 2.91 | + +SLEEF/Accelerate rows are vector-interpreter fallbacks because accelerated +backends are intentionally not fused into the per-lane generated JIT. System +math retains generated-JIT support. Fast-math does not improve these +transcendental maps measurably here; its purpose is permission, not an expected +speedup. Accelerate is consistently fastest for transcendental maps. SLEEF u35 +is faster than u10 and still within the audit's documented accuracy bounds for +these inputs; the u10/u35 split is observable rather than masked by the +process-global default. The pure arithmetic `sqrt` reduction favors generated +system JIT. + +Reproduce with `bench/mathlib-performance.py`; raw rows are in +[mathlib-performance.json](mathlib-performance.json). diff --git a/plans/menudet-ci-qualification.md b/plans/menudet-ci-qualification.md new file mode 100644 index 000000000..80fd7a6ea --- /dev/null +++ b/plans/menudet-ci-qualification.md @@ -0,0 +1,436 @@ +# Menudet CI qualification — 2026-10-09 + +This is CI evidence, not an M7/top-level status update. The parent owns +`plans/menudet-numpy-compat.md` and `plans/menudet-m7-scope-review.md`; neither was +edited or staged here. The initial local diagnosis below is retained as historical +evidence; the publication/remote qualification continuation supersedes its earlier +authorization and unpublished-revision statements. + +## Green native and explicit-pair checkpoint + +**Native and explicit paired qualification passed. Release qualification remains +incomplete**: NumPy 1.26 CTable UTF-8 fixtures, Python/Pyodide contract-test failures +and distribution gates below are still open. Parent alias-removal commits are not +part of this pair. + +- Native: `d12ca6427782a21a959255c6c2546031a75fd9bb`; + [green native/WASM run 37963314217](https://github.com/Blosc/miniexpr/actions/runs/37963314217). +- Python code checkpoint: `6f8a45f8f258c4606e8cbf6999c850845c24c259`; + [green explicit-pair run 37963360530](https://github.com/Blosc/python-blosc2/actions/runs/37963360530), + dispatched with the **full exact native SHA** above. Downloaded revision artifacts + from all three platforms independently contain this exact pair. +- The source-selector/report follow-up selects that same native SHA and changes + no Python execution code. Its resulting Python SHA is independently dispatched + again before completion; the final response/local evidence addendum records that + exact result, not an assumption that a documentation change inherits CI. + +| Native job | CTest passed | Configuration / retained gate | +| --- | ---: | --- | +| Linux x64 | 431 | TCC enabled; required portable TCC plus required CC corpora | +| Linux ARM64 | 431 | TCC enabled; required portable TCC plus required CC corpora | +| Linux ARM64 TCC-disabled | 338 | CC remains available and required; existing full-DSL TCC-cache exclusion | +| macOS ARM64 | 431 | Required portable TCC plus required CC corpora | +| Windows x64 | 335 | ClangCL Release, builtin-identity regression retained | +| Windows ARM64 | 244 | Existing unsupported bundled-TCC/TCC-JIT configuration disabled | +| Standalone wasm32 | 63 | Side-module helper trace explicitly confirms `compiler=tcc` | + +| Explicit Python pair job | Native CTest | Python required modules | Required actual portable JIT | +| --- | ---: | ---: | ---: | +| Linux x64 / Python 3.12.15 / NumPy 2.5.3 | 431 | 488 passed, **zero skips** (66.84 s) | 207 passed, **zero skips** (25.59 s) | +| macOS ARM64 / Python 3.12.15 / NumPy 2.5.3 | 431 | 488 passed, **zero skips** (128.44 s) | 207 passed, **zero skips** (48.49 s) | +| Windows x64 / Python 3.12.15 / NumPy 2.5.3 | 335 | 488 passed, **zero skips** (63.31 s) | Not a supported portable host-pointer JIT target in this qualification | + +All four authoritative corpora and required native logical-array capabilities were +selected explicitly. The v2 corpus's two deliberate unsupported-capability negative +cases are checked as such in both runners; they are not missing required numerical +capabilities or pytest skips. Optional acceleration requests are not mislabeled as +compiled execution: separate required-TCC, required-CC and actual-JIT gates establish +the supported routes. No value assertion, ULP/accuracy tolerance or failed platform +job was weakened or removed. + +## Final task-qualified pair (supersedes historical/pending statements below) + +**Native and explicit-pair CI are green. Broader/release CI is not fully green.** +The final result artifact is local so recording the final tested SHA/run does not +create a new, unqualified revision. Full published investigation/matrices are in +[the task report at Python 442bf8a7](https://github.com/Blosc/python-blosc2/blob/442bf8a7ee3b858fcfbbbf1e4e6a69dc1c55e131/plans/menudet-ci-qualification.md). + +| Component | Exact task-qualified SHA | Green run | +| --- | --- | --- | +| Native | `d12ca6427782a21a959255c6c2546031a75fd9bb` | [37963314217](https://github.com/Blosc/miniexpr/actions/runs/37963314217) | +| Python, explicit native override | `442bf8a7ee3b858fcfbbbf1e4e6a69dc1c55e131` | [37964800176](https://github.com/Blosc/python-blosc2/actions/runs/37964800176) | + +The paired workflow was dispatched with that full exact native SHA. Downloaded +`paired-revisions.txt` artifacts from Linux, macOS and Windows all independently +confirm both full SHAs. Publication was exclusively task-scoped. Parent native +`b0541bb54f65cbe8cdb7d9de2601372117a1ffaf`, Python +`cf9cf3596708d69f1318c739613e03b6fcb56d84`, their alias cleanup and ongoing work +remain in the original root checkouts and **were not pushed, reset or included**. +Later CI fixes used separate `menudet-ci-qualification` worktrees rooted at native +`216c603` / Python `36023f57`, pushed as explicit `HEAD:refs/heads/numpy-compat`. +This pair does **not** qualify the parent's new alias-removal corpus/adapters. + +| Supported native job | Passed CTest | +| --- | ---: | +| Linux x64 / TCC enabled | 431 | +| Linux ARM64 / TCC enabled | 431 | +| Linux ARM64 / TCC disabled, CC still required | 338 | +| macOS ARM64 | 431 | +| Windows x64 / ClangCL Release | 335 | +| Windows ARM64 / existing TCC-disabled configuration | 244 | +| Standalone wasm32 / side-module JIT trace required | 63 | + +| Explicit Python 3.12.15 / NumPy 2.5.3 pair | Native CTest | Required Python modules | Required actual JIT | +| --- | ---: | ---: | ---: | +| Linux x64 | 431 | 488, zero skips (57.48 s) | 207, zero skips (25.61 s) | +| macOS ARM64 | 431 | 488, zero skips (130.98 s) | 207, zero skips (38.75 s) | +| Windows x64 | 335 | 488, zero skips (52.50 s) | Not a qualified portable host-pointer JIT target | + +All four authoritative corpora and required logical-array capabilities were +selected explicitly. Two deliberate unsupported-capability v2 negative cases +remain checked in both runners; they are not missing numerical capabilities or +pytest skips. Required native TCC/CC and actual Python JIT gates prevent successful +interpreter fallback from being counted as compiled execution. No numeric +assertion/tolerance or platform job was weakened or hidden. + +Additional task fixes after the first report: Windows corpus input is closed before +the native reader opens it (sharing regression added); exact reviewed x64/ARM64 +observations handle the already platform-qualified NumPy nonfinite cast without +changing native rejection/baselines; arithmetic time budgets are 180 s; Windows +Ninja paired linkage is static-only. Linux TCC required glibc multiarch headers +and staged/installed **existing** TinyCC compiler headers beside `libtcc`. The +working runtime then exposed a genuine floor-division FP-status mismatch; one +non-inlined scalar implementation now serves interpreter and JIT bridge, retaining +exact status/value assertions and failure diagnostics. Native required TCC and +all final supported native/WASM jobs passed these fixes. Local fresh static build +passed 431/431 and required TCC also passed using its installed runtime path. + +Main/release dependency defaults and pins are unchanged. Branch-specific Python +CI selects the exact native revision through `.github/menudet-native-ref`. CI +installs existing dev dependency Pandas for Arrow conversions; the NumPy 1.26 job +alone pins PyArrow 21.0.0 because PyArrow 26 rejects NumPy 1 at import without +declaring that requirement in `Requires-Dist`. No shipping dependency was added. +Logs contain existing SLEEF/compiler diagnostic warnings and macOS static duplicate +`-lm`/archive linker warnings; green CI is not claimed to be warning-free. + +### Concrete remaining release gates at the final pair + +- [Tests 37964801216](https://github.com/Blosc/python-blosc2/actions/runs/37964801216): + Linux Python 3.12/3.14, macOS and Windows green. NumPy 1.26 remains red: + **14 failed, 12,185 passed, 354 skipped** (159.98 s). Failures are unchanged + `tests/ctable/test_pandas_arrow_import.py` fixtures requesting NumPy 2 + `StringDType` UTF-8 storage, correctly rejected under NumPy 1.26. +- [Python/Pyodide 37964801139](https://github.com/Blosc/python-blosc2/actions/runs/37964801139): + **80 failed, 10,480 passed, 1,011 skipped, 11,923 deselected, one xpassed** + (510.54 s). Seventy reduction tests assume host `intp` rather than portable + int64/uint64 defaults; nine demand unsupported WASM FP flags/threading; one + invokes unsupported subprocesses. Failures remain visible. Standalone WASM + success is not a claim of paired Python WASM success. +- Release wheel/sdist workflows were inspected, not dispatched; no exact-pair + abi3/free-threaded/wheel qualification, no-GIL claim or optional clean-install + packaging acceptance. Other interpreter/NumPy/architecture cross-products, + sanitizer/stress and M7 matrix/docs/scope/performance gates remain open. + +Required native/explicit-pair qualification is complete. Broader all-workflow and +release acceptance remain incomplete; neither historical green runs nor the +parent's local alias tests close those separate gates. + +## Authorized publication and remote qualification continuation + +The user explicitly authorized task-scoped commits, pushes and workflow dispatch. +Only the four native fix/regression files were staged. Native fixes are published +as `7fa177713112561c363206c97f7faf1223ab4230` (parent `25a4aa4`). Python's existing +task baseline `6c863ebacc0d47359c9f5890dda2bef0dce7b293` was also pushed; its remote +branch had still pointed at `cf6f25c1`. No dependency default or pin was changed. + +Runs launched at these exact revisions: + +| Workflow | Run | Revision / selection | Status | +| --- | --- | --- | --- | +| Native CI | [37952303800](https://github.com/Blosc/miniexpr/actions/runs/37952303800) | native `7fa177713112561c363206c97f7faf1223ab4230` | Success, seven jobs | +| Explicit paired qualification | [37952373294](https://github.com/Blosc/python-blosc2/actions/runs/37952373294) | Python `6c863eba`; dispatch `native_ref=7fa177713112561c363206c97f7faf1223ab4230` | Failed; findings below | +| Python Tests | [37952354685](https://github.com/Blosc/python-blosc2/actions/runs/37952354685) | Python `6c863eba`, unchanged release dependency | Failed; draft 1.0 dependency lacks 1.1 | +| Python Tests (WASM) | [37952354689](https://github.com/Blosc/python-blosc2/actions/runs/37952354689) | Python `6c863eba`, unchanged release dependency | Failed; draft 1.0 dependency lacks 1.1 | + +The push-triggered paired run `37952354858` selects a branch, not an explicit SHA; +the dispatched run above is the authoritative exact-selection qualification. +Initial dispatch returned 404 because the Python workflow was not yet published; +dispatch succeeded after pushing the existing Python baseline. + +### Inspected supported matrices and evidence boundaries + +- Native `ci.yml`: Linux x64, macOS ARM64, Windows x64; Linux ARM64 TCC enabled + and disabled; Windows ARM64 with bundled TCC/TCC JIT disabled; standalone wasm32 + with side-module JIT trace assertion. Disabled-TCC jobs preserve required host-CC + corpus tests where supported. Their existing exclusion of the full-DSL TCC + runtime-cache test is configuration-specific, not a new qualification skip. +- Paired `menudet-paired.yml`: Linux x64, macOS ARM64, Windows x64; conda `blosc2`, + Python 3.12, NumPy 2.5.3; native artifact build and full CTest plus five explicit + Menudet Python modules, all four corpora and required array capabilities. +- Python `build.yml`: default-dependency full suite on the three platforms at + Python 3.12, plus Linux Python 3.12 / NumPy 1.26 and Linux Python 3.14. The 1.26 + job builds with NumPy 2 headers then pins the compatible runtime and Zarr range. + These are host/default-dependency checks, **not** NumPy 1.26 qualification of the + explicit experimental native pair. +- Python `wasm-tests.yml`: Pyodide `314.0.0`, Python 3.14, whole wheel suite and + certification scripts; unchanged release dependency, **not** explicit-pair WASM. +- Release `cibuildwheels.yml` inspected, not dispatched: Linux x64/ARM64, Windows + x64/ARM64, macOS x64/ARM64; cp311-abi3 and cp314t/cp315t wheels; abi3 install + matrix Python 3.11–3.15; Pyodide cp313/cp314. Existing cp315 macOS x64 test + exclusion reflects missing dependency wheels; free-threaded import enables the + GIL and is not no-GIL qualification. None constitutes current-pair wheel evidence. + +### First remote iteration and follow-up fixes + +Native `7fa1777` passed all seven jobs in run `37952303800`. Explicit-pair run +`37952373294` failed honestly: Windows Ninja generated shared import and static +libraries with the same `miniexpr.lib` path; macOS optional arithmetic compilation +exceeded 60 seconds; Linux's NumPy infinity-to-int64 sentinel was signed minimum, +not the corpus generator's ARM64 signed maximum. + +Follow-up native commit `216c603ef64d7e49bbbb8fc6001f51c74bfb3d0b` passed all seven +jobs in [37954150929](https://github.com/Blosc/miniexpr/actions/runs/37954150929). +It raises arithmetic corpus **time budgets** to 180 seconds (no numeric policy +change) and records reviewed **exact** x64/ARM64 NumPy observations for the already +platform-qualified nonfinite cast case. The original expected value, divergent +classification and native `evaluation_error` baseline are unchanged. The Python +drift checker selects the explicit machine observation; unlisted machines retain +the original reference and fail on drift. New regressions require exact comparison +and forbid machine variants without a platform qualification. + +Python follow-ups select static-only native linkage in the paired workflow, use +Windows-native source paths, and require actual TCC/CC/Clang portable JIT execution +on Linux/macOS as a separate test gate. The JIT test's three old assertions that +division/shifts must fall back were obsolete after expanded lowering. They are +replaced by **required compilation**, bit-exact interpreter/value/status parity, +zero/overflow/nonfinite/invalid-shift guard checks (nine new backend cases); mixed +uint64/signed-weak comparison and fast-math fail-closed assertions remain intact. + +Broader Tests `37952354685` and Tests (WASM) `37952354689` failed because their +unchanged release dependency accepts draft 1.0 only while new tests exercise 1.1. +CI now checks out `.github/menudet-native-ref` (exact native `216c603`) and sets an +explicit source override **only on `refs/heads/numpy-compat`** in those workflows. +Main/release defaults and native/Pyodide dependency pins remain unchanged. Release +wheel workflows are not modified or dispatched. The explicit-pair dispatch still +selects a full native SHA independently of that branch-specific CI file. + +Follow-up local checks (all `conda run -n blosc2`): native **430/430** (86.59 s), +five-module explicit pair **487 passed / zero skipped** (66.98 s), actual-JIT +**207 passed / zero skipped** (142.34 s), Ruff lint/format and `git diff --check` +passed. No compilation source changed in the follow-up native commit; no new +compiler warnings were emitted by the incremental native build. + +### Second remote iteration, isolation and remaining failures + +Python `65a25b8a5036134057ce79477e7db070d0d54bae` was published with the initial +workflow/reference/JIT-test fixes. Run +[37955282982](https://github.com/Blosc/python-blosc2/actions/runs/37955282982) +passed macOS but exposed Windows temporary-file sharing and Linux TCC headers. +Python `36023f571c6f2c4d59fb68415840b72b35aefdc6` closes the corpus input before +launching the native subprocess (new regression also checks cleanup), adds JIT +trace evidence, and fixes CI-only Pandas/Arrow test runtime requirements. +The release dependency pins remain unchanged. The NumPy 1.26 job alone uses +PyArrow 21.0.0: PyArrow 26 rejected NumPy 1.26 at import without expressing that +requirement in its PyPI `Requires-Dist` metadata. Pandas is an existing dev +dependency needed by Arrow's dictionary conversions; it is installed in CI rather +than adding a new shipping dependency. + +At Python `36023f57` / native `216c603`, explicit-pair run +[37957000054](https://github.com/Blosc/python-blosc2/actions/runs/37957000054) +passed Windows and macOS. Linux's **required** TCC test failed (not skipped): +`/usr/include/stdint.h:26: error: include file 'bits/libc-header-start.h' not found`. +Native follow-up `b2c88e9a22e8121024c28991763cfcf22687fbeb` discovers existing +architecture-specific Linux system include directories through libtcc's optional +system-include API, complementing the existing multiarch library discovery. +No dependency was added. New native `numpy_compat_portable_tcc` requires actual +compilation on supported bundled Linux/macOS TCC builds. It passed locally in a +fresh static native build; Linux needs its own remote result. + +The parent independently committed alias cleanup at native `b0541bb` and Python +`cf9cf359` **without publishing it**. Continued CI fixes use separate worktrees +rooted at native `216c603` / Python `36023f57`, with task branch +`menudet-ci-qualification`. Only task descendants are pushed explicitly as +`HEAD:refs/heads/numpy-compat`. Parent alias commits/files, M7 plans and +`graph-preparation.md` are not staged, changed, reset or pushed by this task. +The final pair does **not** qualify the parent's alias-removal corpus or adapters. + +Concrete broader release gates still open (not removed from CI): + +- [Tests 37957000018](https://github.com/Blosc/python-blosc2/actions/runs/37957000018), + Python `36023f57` / native `216c603`: Linux Python 3.12/3.14, macOS and Windows + passed. Linux NumPy 1.26 failed **14 tests** in + `tests/ctable/test_pandas_arrow_import.py`: those fixtures request NumPy 2 + `StringDType` UTF-8 storage, which the package correctly rejects on 1.26. + Other results: 12,116 passed / 423 skips. No unrelated CTable implementation or + test was changed to conceal these errors. +- [Pyodide 37955282922](https://github.com/Blosc/python-blosc2/actions/runs/37955282922), + Python `65a25b8a` / native `216c603`: **80 failed, 10,479 passed, 1,011 skipped** + (758.40 s). Failures are 70 reduction tests assuming host `intp` rather than + the documented portable int64/uint64 accumulator defaults, nine tests demanding + unavailable WASM FP flags/threading, and one subprocess test on a runtime without + processes. These failures remain visible; no WASM job/test was hidden or numerical + policy weakened. Standalone native WASM success is not paired Python WASM success. +- GitHub core API quota temporarily exhausted at 16:11 UTC; reset header was + 16:17:53 UTC. Work waited for reset and resumed. Watches now use a 60-second + interval to avoid unnecessary quota consumption; no result is inferred from a + watch interrupted by API errors. + +Native `216c603` run `37954150929` counts: Linux x64 430, Linux ARM64 TCC 430, +Linux ARM64 TCC-disabled 338, macOS ARM64 430, Windows x64 335, Windows ARM64 244, +WASM 63. All passed, including the WASM side-module trace assertion. Native logs +also contain pre-existing SLEEF macro/always-inline/posix_memalign warnings and +`dsl_jit_backend_libtcc.c` diagnostic format-truncation warnings; green CI is not +claimed to be warning-free. + +### Required TCC runtime asset qualification + +Python `e44c0044f904bdc0ebee16ea4737e273d63949b9` selected native `b2c88e9`. +[Paired 37958957787](https://github.com/Blosc/python-blosc2/actions/runs/37958957787) +passed Windows/macOS but the new **required native TCC** test failed on Linux. +Native `b2c88e9` [37958780104](https://github.com/Blosc/miniexpr/actions/runs/37958780104) +also failed Linux x64/ARM64 TCC while the other five jobs passed. The gate was +not removed or converted back to optional fallback. + +Native diagnostic commit `4aabfe873d044e64583247c7322d53c6b06ff9de` enabled trace +on that test. [37960125294](https://github.com/Blosc/miniexpr/actions/runs/37960125294) +identified the second missing asset exactly: +`/usr/include/string.h:33: error: include file 'stddef.h' not found`. +The multiarch glibc header fix was working; compiler-provided TinyCC headers were +not staged or installed beside the relocated runtime library. + +Native `aefe19dfc893877eb76818d0d4c57adb78fbacdf` stages/installs the existing +bundled TinyCC `include/` tree beside `libtcc`. No new dependency, native pin, +numeric assertion or tolerance is involved. A fresh static local native build +passed **431/431** (103.08 s), including required TCC. Installation to a private +prefix succeeded, and required TCC also passed with `ME_DSL_JIT_LIBTCC_PATH` +pointing at that installed runtime (0.41 s), rather than the staged build copy. +Local static linkage emitted duplicate `-lm` linker warnings, recorded separately +from the prior shared-build no-warning result. Remote Linux/ARM64 must confirm +the runtime fix; local Apple results alone are not Linux evidence. + +The now-working runtime exposed a genuine Linux x64 floor-division floating-status +mismatch in native `aefe19d` +[37961318269](https://github.com/Blosc/miniexpr/actions/runs/37961318269) and its paired +run [37961376270](https://github.com/Blosc/python-blosc2/actions/runs/37961376270). +Native `d12ca6427782a21a959255c6c2546031a75fd9bb` keeps a single non-inlined scalar +floor-division implementation for interpreter and bridge calls, preventing GCC +from specializing two inlined copies with different floating flags. The exact +status/value assertions stay intact; diagnostic output now names source, mask and +both statuses on failure. The green Linux x64/ARM64 native and Linux/macOS actual +JIT results above qualify this fix without a fallback or tolerance concession. + +Remaining release gates include experimental-pair NumPy 1.26 and other interpreter +versions, paired Python ARM64 Windows/Linux and WASM integration, release wheel/ +sdist qualification against the selected native revision, clean-install optional +packaging, sanitizer/stress coverage and M7 scope/docs/performance acceptance. +No skipped corpus, increased tolerance or removed platform is accepted as a CI fix. + +## Revision boundaries + +- Native revision supplied at delegation: + `2567eb6c9aca059c0f19277a09d6496b65b86d97`. +- Native HEAD observed during this task: + `25a4aa4e2afb05f350afa50a928d5478ff05fa7a`. +- Python HEAD: + `6c863ebacc0d47359c9f5890dda2bef0dce7b293`. +- Local tests below use native `25a4aa4` **plus the working-tree fixes below**. + They do not qualify the clean native SHA or an unpublished final revision. +- No state-changing Git or GitHub operation was performed by this task. + +## Published failures inspected with read-only `gh` + +| Run | Exact native SHA | Result | +| --- | --- | --- | +| [37901442377](https://github.com/Blosc/miniexpr/actions/runs/37901442377) | `5d6b1a37e34cddb9f194a10a3157168a5fa92526` | Linux x64/ARM64 builds, Windows x64/ARM64 function tests, WASM artifact test failed; macOS passed | +| [37934733524](https://github.com/Blosc/miniexpr/actions/runs/37934733524) | `25a4aa4e2afb05f350afa50a928d5478ff05fa7a` | Same platform failures; Windows also exposed Boolean `real()` result inference | + +The newer run was discovered during the task: its base native revision is now +published, contrary to the initial unpublished assumption. The working-tree fixes +are not published and have no CI result. + +Python's latest observed published branch runs were Tests `37896228314` and +Tests (WASM) `37896228386`, both successful at +`cf6f25c1020c13864413e97b39e466c893b77a7b`. Those historical successes do **not** +qualify Python `6c863eba` or the current pair. No paired workflow run was listed. + +## Targeted fixes + +In `/Users/faltet/blosc/miniexpr`: + +1. `CMakeLists.txt`: make `m` a public adapter dependency on non-Windows. + Linux logs show `fesetround` missing for the adapter consumer and `fegetenv` + missing for the conformance runner. A shared miniexpr library's private `m` + dependency cannot satisfy these direct consumer references. The local runner + link command now contains `libminiexpr_artifact.a`, miniexpr, and `-lm`. +2. `tests/CMakeLists.txt`: embed the affine JSON fixture into the WASM virtual + filesystem at the exact compiled-in path. `test_dsl_artifact` previously aborted + at `read_fixture`'s `fopen` assertion. This preserves the test instead of skipping it. +3. `src/functions.c`: recognize both the direct CRT `remainder` symbol and the + registered builtin address when selecting NumPy modulo. Windows CRT inline/import + aliases otherwise select C remainder semantics, reject narrow integer signatures, + and produce wrong exceptional floating results. +4. `CMakeLists.txt`: propagate Windows `/OPT:NOICF` to the library and its consumers. + Builtin function-pointer identity is semantic; Release identical-code folding + must not merge `real`/`conj` callbacks with different Boolean inferred dtypes. +5. `tests/test_dsl_numpy_builtin_identity.c`: exercise Boolean `real` versus `conj` + inference and signed int8 NumPy remainder inference/values. This runs on native + and WASM and is included in Windows Release CTest builds. + +No dependency pins, workflow files, unrelated plans, or user files were changed. + +## Local qualification + +All builds, installation and tests used `conda run -n blosc2`. The local environment +is macOS ARM64, Python 3.14.4, NumPy 2.5.3, AppleClang 21; WASM uses Emscripten 5.0.0. +Build directories and logs are under +`/private/var/folders/tb/7hwq2y354bb_68xwxjwjwwlr0000gn/T/opencode/`. + +- Native Release/artifact build: succeeded. Final full suite: + **430/430 passed** (31.13 s), including both required-CC + arithmetic/function corpus tests. +- WASM Release/artifact build with the CI options: succeeded. Final full suite: + **63/63 passed** (28.66 s), including the previously + failing fixture test. +- New builtin-identity regression: passed separately on native and WASM. +- WASM side-module trace gate: passed and emitted + `[me-dsl] jit runtime built: fp=strict compiler=tcc`. +- Python editable extension rebuilt successfully with + `--config-settings=cmake.define.FETCHCONTENT_SOURCE_DIR_MINIEXPR=/Users/faltet/blosc/miniexpr`. + This selects the patched native source rather than the release pin. +- `git diff --check`: passed. +- Compiler warnings: none in the standalone native/WASM builds. Native bundled + tinycc emitted one GNU make `jobserver unavailable: using -j1` warning. + +- Python explicit-pair run: **483 passed, zero skipped** (71.32 s). Selected + `tests/test_menudet_arrays.py`, `tests/test_menudet_native_graph.py`, + `tests/test_menudet_functions.py`, `tests/test_menudet_arithmetic.py`, and + `tests/test_menudet_conformance.py`, with `-q -n 0` and these environment variables: + + ```text + MENUDET_REQUIRE_ARRAY_RUNTIME=1 + MENUDET_NUMPY_FUNCTION_CORPUS=/Users/faltet/blosc/miniexpr/tests/numpy-compat/functions-v1.1.json + MENUDET_NUMPY_ARITHMETIC_CORPUS=/Users/faltet/blosc/miniexpr/tests/numpy-compat/arithmetic-v1.1.json + MENUDET_NUMPY_CORPUS=/Users/faltet/blosc/miniexpr/tests/numpy-compat/vectors.json + MENUDET_NUMPY_CORPUS_V2=/Users/faltet/blosc/miniexpr/tests/numpy-compat/vectors-v2.json + MENUDET_NUMPY_RUNNER=/private/var/folders/tb/7hwq2y354bb_68xwxjwjwwlr0000gn/T/opencode/menudet-ci-native/tests/numpy_compat_runner + ``` + + The preliminary unconfigured Python run (467 passed, 16 skipped) is not treated + as full corpus qualification. Python build output contained no warning/error. + +## Remaining gates / blockers + +- The patches need actual Linux x64, Linux ARM64 (TCC on/off), Windows x64, + Windows ARM64 and GitHub WASM execution. Local macOS/WASM success does not prove + Windows alias/folding behavior or Linux linker behavior. No local Windows/Linux + qualification was performed. +- Python `6c863eba` is not represented by the historical Python green runs. + The current paired workflow builds a native source override and explicitly + requires array capabilities and all four corpora; dispatch can select an exact + native SHA via `native_ref` and uploads both checked-out SHAs. +- Final native fixes and the Python revision must be remotely available for + GitHub CI to qualify the final pair. Publication/workflow dispatch was not + authorized in this task, so no new CI run was launched. +- Current-pair NumPy 1.26, Linux/Windows Python paired results, Python WASM integration, + and the broader Python test suite remain separate gates; no claim of current-pair + coverage is made from historical green results. diff --git a/plans/menudet-complex-support.md b/plans/menudet-complex-support.md new file mode 100644 index 000000000..3db03d1fe --- /dev/null +++ b/plans/menudet-complex-support.md @@ -0,0 +1,355 @@ +# Menudet complex support: implementation and handoff plan + +## 1. Goal and scope + +Implement a consistent **interpreter-first complex contract** for Menudet on +macOS, Linux, and WASM32. Support `complex64` and `complex128` inputs, outputs, +constants, captures, locals, and intermediate values. Windows must reject +complex kernels explicitly, while continuing to build and execute real kernels. + +Complex evaluation must not call the originating Python function, use NumPy as +an execution fallback, or retry the full/legacy DSL. NumPy is a numerical test +oracle, not a runtime dependency of a native artifact. + +Complex JIT is **not required** for the first implementation. `jit=True` is a +best-effort request: a kernel requiring complex computation should execute in +the typed interpreter if its JIT backend cannot implement it. Select that path +before execution; never replay a partially executed failing JIT kernel. + +“Transparent fallback” means transparent JIT-to-interpreter selection within +the supported Menudet contract. It does not mean accepting every NumPy +operation or silently executing unsupported language constructs. + +Out of scope initially: + +- Windows complex execution, including MinGW-specific exceptions. +- Complex JIT/AOT bridges, vectorized complex math, and performance tuning. +- float16, extended precision, records, datetime/timedelta, objects, or + variable-length string support. +- Changing trusted legacy recipe semantics or removing their explicit opt-in. + +## 2. Working environment and state + +Two repositories are involved: + +- Python-Blosc2: `/Users/faltet/blosc/python-blosc2` +- Native miniexpr: `/Users/faltet/blosc/miniexpr` + +Read both repositories' `AGENTS.md` before editing. Use the `blosc2` conda +environment for Python, builds, and tests. Do not assume the editable install +loads the extension just rebuilt; print both module paths before testing. + +This plan was written after the initial migration of source-authored LazyUDFs +to Menudet. There are also **uncommitted native and Python changes** extending +artifact-load options and compatibility dispatch. Inspect `git status` and +diffs in both repositories; preserve this work. Do not reset the repositories. +Do not assume the dependency pin includes those uncommitted changes. + +An earlier investigation mistakenly compared the pinned miniexpr build with +source from a newer sibling checkout. Avoid repeating that error: record the +actual source override, native revision/dirty status, build directory, and +loaded extension for every result. + +Committing/pushing requires the user's explicit instruction. Follow repository +rules for CI monitoring, particularly `gh run watch --interval 60 --exit-status`. + +## 3. Verified baseline: do not overstate legacy support + +The following observations motivated this work: + +1. On native macOS, forced legacy execution of identity and `z*z + 1` succeeds + for both complex widths. Successful execution with `jit=True` does **not** + establish that a complex JIT kernel was generated. +2. Native Windows compilation is explicitly rejected in `src/miniexpr.c` with + `ME_COMPILE_ERR_COMPLEX_UNSUPPORTED` and a C99-complex-ABI diagnostic. +3. Python-Blosc2 disables complex legacy DSL kernels on Windows **and WASM** in + `src/blosc2/lazyexpr.py`. Constructors and ordinary expressions can use + separate NumPy paths; those are not evidence of native DSL support. +4. After rebuilding the local WASM target, Node execution of + `build-wasm-menudet/tests/test_complex_functions.js` passed all 10 tests: + conjugation, real/imaginary extraction, and scalar/complex division. +5. Additional standalone WASM complex128 DSL probes passed arithmetic, local + assignment, a loop, and complex truth-value branching. They reported + `jit=0`, confirming interpreter execution. +6. Legacy's `is_complex_supported_function()` in `src/functions.c` admits a + limited whitelist: basic arithmetic, negation, powers, square root, + absolute value, conjugation, real/imaginary extraction, and reduction nodes. + Comparison nodes are rejected there. Admitting reduction nodes is not a + claim that all reductions or numerical edge cases are qualified. +7. Legacy generated JIT code excludes complex dtypes (`src/dsl_jit_cgen.c`). + +Conclusion: reuse appropriate numerical primitives, not legacy's overall +portability or correctness claims. Windows requires more foundational work; +WASM already has useful C complex interpreter machinery. + +## 4. Code map to audit + +### miniexpr + +- `src/miniexpr.h`: dtype IDs, public values/views, compile/evaluation errors. +- `src/miniexpr.c`: Windows rejection, compilation admission, option scoping. +- `src/functions.c`, `src/functions.h`: existing complex operations and platform + adapters; identify which helpers are safe to reuse. +- `src/dsl_compile.c`, `src/dsl_compile_support.c`: locals, type inference, + expressions, literals, return conversion, control-flow joins. +- `src/dsl_portable_types.{c,h}`: promotion, casts, scalar numerical rules. +- `src/dsl_portable_expr.c`: typed admission and evaluation, truth values, + comparisons, unary/binary operations, batch-path eligibility. +- `src/dsl_portable_reduce.h`: reduction behavior and accumulator types. +- `src/dsl_eval.c`: frame/local storage, copying values, masks, JIT dispatch. +- `src/dsl_artifact.c`, `src/miniexpr_artifact.h`: manifest types, constants, + capabilities, widths, descriptors, overlap/alignment checks, load options. +- `src/dsl_array.c`: array-view widths, byte order, broadcasting, strides, + reductions, storage readers, output writers. +- `src/dsl_graph*.c`: graph typing, serialization, scheduling and source views. +- `src/dsl_portable_jit.c` and JIT backend/cache files: early ineligibility, + trace reasons, source generation and cache invalidation if needed. +- `tests/test_complex_functions.c`, `tests/test_dsl_portable_types.c`, + `tests/test_dsl_artifact.c`, `tests/test_portable_jit_parity.c`, and array/graph + tests: existing rejection assumptions and reusable test infrastructure. +- Native language/artifact specifications and `.github/workflows/ci.yml`. + +### Python-Blosc2 + +- `src/blosc2/portable_kernel.py`: dtype/scalar descriptors, weak captures, + manifest export, validation, loading, block/array execution APIs. +- `src/blosc2/dsl_kernel.py`: source normalization, captures, dtype inference. +- `src/blosc2/blosc2_ext.pyx`: NumPy dtype mapping, buffer widths/alignment, + descriptors, native error translation, prefilter admission and scratch sizing. +- `src/blosc2/dsl_artifact_bridge.h`: optional-runtime capability shims. +- `src/blosc2/dsl_execution.py`: migrated LazyUDF dispatch, chunk-local groups, + scalar-return broadcasting, dtype gates and native JIT requirements. +- `src/blosc2/proxy.py`: `@blosc2.jit` control-flow wrapper. +- `src/blosc2/{storage_readers,resident_execution,native_graph}.py`: execution + admission, operation safety assumptions, size calculations and fallback paths. +- `src/blosc2/ndarray.py`, `src/blosc2/lazyexpr.py`: constructor/expression + compatibility policies. Do not remove all legacy guards in one sweep. +- `doc/reference/portable_dsl.rst` and the portable/DSL/expression tests. + +Use targeted searches: the above is an audit map, not a requirement to modify +every file. Existing complex dtype IDs in Cython do not imply portable support. + +## 5. Phase A: settle the contract before implementation + +Write a short native specification change and tests for the decisions below. +Use the project's declared NumPy-style numerical profile as the reference, +not assumptions about C complex behavior. + +### Representation and manifest + +- Define exact array storage: two components of the declared float width, + component order, byte order, size, and alignment. +- Define endian-stable constant/capture encoding preserving each component's + signed zero, infinities, and NaN bits where the existing contract requires it. + Prefer an extension of the existing IEEE-hex encoding rather than JSON numbers + or Python `repr(complex)`; document the precise byte layout. +- Define whether source `j` literals are admitted. Reuse the existing grammar + where sound; exporting a complex capture must not depend on literal syntax. +- Distinguish ordinary Python complex captures (weak scalars) from NumPy complex + scalars (strong typed scalars), including explicit capture dtype overrides. +- Decide capability/version signaling. Do not silently reinterpret an old + constant encoding or assume an older 1.0 reader accepts newly added dtypes. + Prefer capability detection/rejection consistent with the current draft policy. + +### Numerical behavior + +Specify and test: + +- Strong and weak promotion for bool, all supported integers, float32/64, and + complex64/128; mixed branch/local joins; inferred real outputs from complex + inputs. Output dtype must not determine intermediate precision. +- Truth tests, equality/inequality, logical operations, `where`, and selection. +- Ordering, extrema, sorting-related semantics: **measure the declared NumPy + reference behavior**. Do not assume NumPy rejects all complex comparisons; + either implement the chosen contract or reject it explicitly in the first cut. +- Unsupported arithmetic such as floor division, remainder, and bitwise + operations: reject during validation where statically identifiable. +- Cast policies `safe`, `same_kind`, and `unsafe`; real-to-complex and + complex-to-real/integer behavior. Decide imaginary-discard diagnostics without + assuming Python warnings are a portable native error mechanism. +- Arithmetic precision, division by zero, overflow/underflow, nonfinite values, + signed zeros, and floating-point flags/support reporting. + +Avoid “every kernel works” claims until an operation support matrix exists. + +## 6. Phase B: native dtype foundation and artifact transport + +1. Admit complex64/128 in portable type validation and public dtype descriptors + only on supported platforms. Preserve the real-only Windows build. +2. Audit every width helper and scalar union/frame slot. Complex128 is 16 bytes; + several current batch/scratch assumptions are bounded by `sizeof(double)`. +3. Add exact scalar load/store, copying, captures, serialization and cast support. +4. Extend artifact constant validation, itemsize/byte-count checks, overflow + protection, alignment and overlap checks. +5. Audit array/reader byte-order conversion: swap the two components separately, + not the whole 16-byte value. Cover strided, broadcast and zero-dimensional + input views. +6. On Windows, reject a complex input, constant, local, or intermediate even + when the final result is real. A real output dtype is not sufficient admission. + +Implementation cautions: + +- Keep public headers buildable with Windows compilers. Do not add unconditional + C99 `_Complex` requirements to portable public data structures. +- Verify native C complex layout against the chosen buffer ABI; use safe copies + or component conversion instead of relying on aliasing-unsafe pointer casts. +- Construct complex infinities/signed zeros carefully. `real + I*imag` can have + different exceptional-value behavior from a proper component constructor. +- Audit ABI/cache versioning before changing shared scalar layouts or tables. + +Acceptance: native and Python-exported artifacts round-trip complex buffers and +constants on the three supported platforms; Windows rejects them clearly. + +## 7. Phase C: interpreter arithmetic and control flow + +Implement the typed scalar evaluator first: + +1. Identity, unary negation, addition, subtraction, multiplication, division, + conjugation and real/imaginary extraction. +2. Complex locals, reassignment, branch joins, truth tests, equality and `where`. +3. Lane-local `if`, `for`, `while`, `break` and `continue` using the existing + control-flow contract. Never substitute whole-array Python truth semantics. +4. Masks and initialization tracking. Inactive/uninitialized lanes must not be + evaluated or contribute errors/FP flags. +5. Real-valued outputs such as `abs(z)`, `real(z)`, and `imag(z)` with the correct + component/result precision and output casting policy. + +Initially exclude complex expressions from the bounded real/integer batch +engine. Correct scalar interpretation is preferable to a real fast path that +silently drops imaginary components or overwrites scratch storage. + +Acceptance: identical supported results with JIT requested and disabled, no +Python callback, no full-DSL fallback, deterministic unsupported-operation errors. + +## 8. Phase D: reductions and complex math coverage + +### Reductions + +- Implement/qualify sum, product, mean, logical reductions, and accumulator dtype + rules before advertising general reduction support. +- Define variance/std outputs and conjugation rules if those operators belong + to the current language. Defer unsupported operators explicitly. +- Cover empty groups, masks, `initial` where supported, NaNs, infinities, and + scalar cardinality. Preserve complete logical groups across slicing/rechunking. +- Decide extrema/comparison semantics from Phase A, not legacy's whitelist. + +### Transcendentals + +Add a declared operation set incrementally: square root and power first, then +exp/log families, trigonometric, inverse and hyperbolic functions as supported +by the language. Audit each existing primitive against the reference profile. + +Test branch cuts from both sides using positive and negative zero, extreme +magnitudes, mixed real/complex inputs, and complex64 rounding. C99 libm behavior +can differ from NumPy and across host libraries; wrappers or narrow documented +exclusions may be necessary. Do not advertise bitwise transcendental parity +across platforms without evidence. + +## 9. Phase E: JIT policy, Python dispatch and storage integration + +1. Reject complex JIT admission based on the **entire typed program**, including + inputs/intermediates feeding a real output. Check generic, arithmetic and ramp + bridges; trace a useful reason for interpreter selection. +2. Propagate Windows unsupported errors rather than disguising them as a JIT + miss or falling back to NumPy/legacy. +3. Extend Python scalar/dtype export and inference, preserving weak/strong + captures. Add native capability checks rather than just deleting `dtype.kind` + gates. +4. Enable supported complex `LazyUDF` and native `@blosc2.jit` control-flow calls + through Menudet. Preserve per-call settings, output identity, casts, slicing, + persistence and original chunk-local reduction groups. +5. Extend portable block/array/reader execution and only then eligible compressed + prefilters. Recheck scratch widths, padded edge scattering and FP handling for + 16-byte output. A general portable path may remain the first correct route. +6. For WASM, test portable interpretation directly before changing Python's + dispatch guards. Native compression prefilter scheduling remains disabled on + WASM; that is independent of complex expression evaluation. +7. Keep explicit JS backend behavior separate. Do not present the existing JS + transpiler as a complex-capable Menudet artifact interpreter. If `js` cannot + execute complex kernels, define explicit interpreter selection or a clear + unsupported error; do not silently use legacy native DSL. +8. Remove only obsolete guards with corresponding platform tests. Trusted saved + legacy recipes must keep their own compatibility policy. + +## 10. Testing strategy and completion criteria + +### Ownership + +Put exhaustive dtype/operator/promotion/edge-value matrices in **miniexpr**. +Python-Blosc2 tests should cover bindings, dispatch, buffer/storage contracts, +and a representative end-to-end set, not duplicate every native cross-product. + +### Native coverage + +- Both complex widths, weak/strong scalars, mixed real/integer types, casts. +- Constants and captures, including malformed manifests, byte order, signed + zeros, infinities, NaNs, capacity/alignment/overlap failures and empty buffers. +- Arithmetic, control flow, masks, reductions and the supported math matrix. +- Real outputs from complex inputs and complex intermediates from real inputs. +- JIT-off/JIT-requested parity; interpreter selection reported accurately. +- Windows compile/load rejection without breaking real kernels or headers. +- macOS/Linux interpreter tests and WASM Node tests using **rebuilt** artifacts. +- ASan/UBSan checks where supported, especially new widths and scalar frames. + +### Python coverage + +- `DSLKernel.export` -> `PortableKernel.from_json` -> block and array evaluation. +- Complex64/128 ndarray, NDArray, scalar and captured inputs. +- `lazyudf` and `@blosc2.jit` control-flow execution, including real outputs. +- Monkeypatch legacy hooks/Python function bodies to fail, proving the migrated + path actually uses Menudet; account for intentionally unsupported platforms. +- NumPy/NDArray outputs, partial and strided selections, padded 2-D/3-D blocks, + persistence and reload, empty arrays, and non-native-endian inputs. +- Compiler/cache/trace options and failure isolation remain correct. +- Explicit Windows/JS errors and WASM interpreter behavior. + +### Qualification + +Do not call the feature complete until there is an exact-revision matrix for +macOS, Linux and WASM covering the declared contract, plus Windows negative +coverage and a green existing real/string suite. Record known numerical +differences and unsupported operations explicitly in the specifications/docs. + +## 11. Build and verification examples + +Run from Python-Blosc2, using the local native override during iteration: + +```bash +conda run -n blosc2 python -m pip install -e . --no-build-isolation \ + --config-settings=build-dir=build-portable-python \ + --config-settings=cmake.define.FETCHCONTENT_SOURCE_DIR_MINIEXPR=/Users/faltet/blosc/miniexpr +conda run -n blosc2 python -c 'import blosc2; print(blosc2.__file__); print(blosc2.blosc2_ext.__file__)' +conda run -n blosc2 python -m pytest -n 0 tests/test_dsl_execution.py +conda run -n blosc2 python -m pytest --tb=short +``` + +Prefer incremental native builds when configured correctly; pip build isolation +can leave cached NumPy include paths pointing at deleted temporary directories. +Do not overwrite another checkout's installed extension during isolated tests. + +From miniexpr, discover the relevant test targets before using these examples: + +```bash +conda run -n blosc2 cmake --build build-portable --parallel 8 +conda run -n blosc2 ctest --test-dir build-portable --output-on-failure +conda run -n blosc2 cmake --build build-wasm-menudet --target test_complex_functions --parallel 8 +node build-wasm-menudet/tests/test_complex_functions.js +``` + +Existing WASM complex tests validate legacy primitives, not the new Menudet +contract. Add and run portable-specific targets too. Do not interpret a passing +suite with skipped Windows tests as evidence of Windows complex support. + +## 12. Suggested delivery sequence + +1. Contract/specification and failing native tests for representation/promotion. +2. Native artifact transport and basic typed interpreter arithmetic. +3. Control flow, masks, casts and real-valued complex operations. +4. Reduction contract and qualified math operations in bounded increments. +5. Python bindings and native LazyUDF/@jit integration. +6. WASM portable interpreter integration and Windows rejection qualification. +7. Documentation, platform support matrix, and representative benchmarks. + +Keep each step independently reviewable. Benchmark setup separately from +evaluation and check actual JIT status. Performance is secondary to a sound +portable contract; do not add a complex AOT bridge until correctness is qualified. diff --git a/plans/menudet-jit-assembly-inspection.md b/plans/menudet-jit-assembly-inspection.md new file mode 100644 index 000000000..f1cdd95f7 --- /dev/null +++ b/plans/menudet-jit-assembly-inspection.md @@ -0,0 +1,158 @@ +# Portable lazy-where assembly inspection + +## Finding + +The previous isolated-process table did **not** establish a genuine TCC execution +advantage. Inspecting the actual AArch64 kernels shows better loop generation from +GCC 16 and Apple Clang 21.0.0. Repeating the production Python calls with interleaved +backend order reverses the earlier ranking consistently. + +Workload: `where(x > 0, y / x, x * 2 + y)`, 262,144 float64 elements, sorted +`x = linspace(-2, 2, n)`, `y = linspace(1, 2, n)`, flat PortableKernel API. +All three artifacts report actual JIT execution and pass reference-value checks. + +Five fresh Python processes each load all three kernels, share input buffers, +warm each backend, then rotate execution order over 31 rounds (discard round zero). +The following are medians in milliseconds; compilation is excluded. + +| Process | TCC | GCC 16 | Clang 21 | +|---|---:|---:|---:| +| 1 | 1.076 | 0.740 | 0.739 | +| 2 | 1.045 | 0.717 | 0.712 | +| 3 | 1.044 | 0.727 | 0.723 | +| 4 | 1.047 | 0.733 | 0.726 | +| 5 | 1.048 | 0.726 | 0.722 | + +GCC/Clang are roughly **1.4–1.5× faster than TCC** in this controlled comparison. +Earlier tables remain records of those measurements, but their where-row compiler +ranking should not be generalized. Core placement, frequency and process/run-order +effects are plausible explanations for the earlier discrepancy; no core-residency +or frequency trace was collected, so the exact environmental cause is unproven. + +## Assembly evidence + +A standalone probe compiles the same portable typed-tree kernel through the native +runtime, captures the relocated machine code (including TCC's in-memory code), and +disassembles it with Xcode llvm-objdump. The kernel bytes are wrapped in a Mach-O +text section for disassembly, not recompiled by a different compiler. Addresses +below are offsets from the captured kernel entry. Bytes after the function's code +are unrelated data and are excluded from this analysis. + +| Property | TCC | GCC 16 | Clang 21 | +|---|---|---|---| +| Kernel code extent | 448 bytes | 320 bytes | 304 bytes | +| Stack reservation | 272 bytes | 96 bytes | 80 bytes | +| Mask handling | Null check on every lane | Separate masked/unmasked loops | Separate masked/unmasked loops | +| Index/input-pointer handling | Repeated stack loads/stores | Loop state in preserved registers | Loop state in preserved registers | +| Comparison | One indirect call per participating lane | Same | Same | +| Arithmetic | Scalar; selected branch only | Scalar; selected branch only | Scalar; selected branch only | + +### TCC + +The loop reloads and stores its index through the stack (`ldur` at `0x30`, `stur` +at `0x58`) and tests the mask pointer every iteration (`0x60–0x74`). It repeatedly +reloads the input-pointer vector and computes element addresses. At `0xf8` it +calls the comparison bridge with `blr x30`, after saving an output address to the +stack at `0xe4`. It reloads operands in the selected branch. This is **more**, not +less, per-lane stack/address work than the optimizing compilers generate. + +### GCC + +At `0x3c`, `cbz x24, 0xb4` selects an unmasked loop once per invocation. That loop +keeps its index in `x21`, uses an indirect bridge call at `0xd0`, and reloads x/y +operands after the call. The selected division is at `0x108`; the other branch +uses scalar `fmul` and `fadd` at `0xec–0xf0`. There is no SIMD and no eager division +on the unselected branch. + +### Clang + +At `0x30`, `cbz x22, 0xa4` similarly selects an unmasked loop once. Its bridge call +is at `0xe0`; `tbnz w0, #0, 0xb0` chooses the division path. It also reloads operands +after the call and preserves loop state in registers. No SIMD is present. + +GCC/Clang save preserved registers in their prologues, but that is a **per-call** +cost, not a spill repeated for every element. The earlier hypothesis that extra +GCC/Clang register spills explain TCC's apparent win is not supported by the code. + +## Bridge-cost experiment + +The standalone probe also interleaves raw kernel invocations on identical buffers +in one process, using either the real comparison bridge or a minimal callback +that just returns `x > y`. It scopes/restores fenv and checks numerical outputs. +The minimal callback is a diagnostic experiment on finite inputs, **not** a +replacement implementing the complete portable comparison contract. + +Sorted-input raw-kernel medians, milliseconds: + +| Callback | TCC | GCC 16 | Clang 21 | +|---|---:|---:|---:| +| Real bridge | 1.361 | 0.910 | 0.990 | +| Minimal finite comparison | 0.697 | 0.301 | 0.227 | + +This confirms a substantial bridge-related cost and again does not show a TCC +advantage. These standalone timings use the native library's host bridge and omit +Python/frontend overhead; they must not be mixed into the production Python table. +A deterministic mixed-sign input was also tested; it did not restore a TCC win. + +## Optimization hints (not implemented by this inspection) + +1. **Inline the common floating comparison path.** Keep an audited exceptional + path for NaNs/signaling NaNs and preserve the established floating-status + contract. Removing the opaque per-lane call should also eliminate associated + operand reloads and improve future vectorization opportunities. +2. **Apply anti-folding protection selectively.** The generated volatile zero and + two literals require stack stores/loads even in optimized code. Volatile reads + are essential where folding would erase observable arithmetic exceptions, but + a blanket rule for every literal is unnecessarily expensive. Replace it only + after tests establish constant-operation and lazy-branch diagnostic parity. +3. **Lower typed nodes to reusable lane temporaries.** The x value appears in both + the comparison and selected arithmetic. Explicit immutable lane values and + cached input bases may reduce duplicate loads/address work; benchmark register + pressure rather than assuming temporaries always help. +4. **Use interleaved repeated-process measurements for compiler comparisons.** + Keep the original isolated measurements for cold-start behavior, but do not + infer a warm compiler ranking from a single process per backend. + +The optimizing compilers already specialize away null-mask checks, so adding an +explicit unmasked loop is not the first optimization priority for GCC/Clang here. +Neither eager NumExpr-style branch computation nor relaxed fast-math is necessary +or justified by these findings. + +Inspection scripts and raw evidence are in the approved OpenCode temporary +directory: `menudet-asm-probe.c`, `menudet-asm-times.csv`, `{tcc,gcc,clang}.c`, +`{tcc,gcc,clang}-captured.asm`, `menudet-where-interleaved.py`, and +`menudet-where-interleaved.json`. No runtime/compiler-policy changes were made. + +## Full-table interleaved rerun + +`tools/menudet_jit_interleaved.py` repeats the three original workloads with all six +backends in each of five fresh processes. It shares identical input buffers, warms +each engine, rotates both workload and backend order, and verifies reference values +before and after sampling. Compilation is excluded; NumExpr uses one thread and +the flat PortableKernel API is used throughout. Supported native routes assert +actual JIT execution rather than counting interpreter fallback as acceleration. + +Each process collects 30 samples per accelerated/array-engine workload and three +interpreter samples (the original slow-interpreter sample budget). The interpreter +participates in the initial rounds only. The report contains 2,295 samples, compiler +versions and the extension hash: `plans/menudet-jit-interleaved.json`. + +Median of the five per-process medians, milliseconds, 262,144 float64 elements: + +| Workload | Interpreter | TCC | GCC 16 | Clang 21 | NumPy | NumExpr (1 thread) | +|---|---:|---:|---:|---:|---:|---:| +| Affine | 1010.738 | 0.640 | 0.284 | 0.250 | 0.302 | 0.367 | +| Polynomial | 758.753 | 0.646 | 0.153 | 0.127 | 0.285 | 0.308 | +| Lazy where | 894.044 | 1.038 | 0.728 | 0.717 | 0.523 | 0.441 | + +Per-process medians are consistent: Clang affine 0.245–0.262 ms, polynomial +0.120–0.132 ms, where 0.709–0.723 ms; GCC where 0.725–0.734 ms and TCC where +1.029–1.051 ms. Clang now outperforms NumPy/NumExpr for affine and polynomial, +while lazy where remains slower than both. The polynomial advantage is approximately +2.2× versus NumPy and 2.4× versus NumExpr. These controlled compiler comparisons +are preferable to the original isolated-run ranking, but still do not measure +core residency/frequency or prove the cause of the earlier discrepancy. + +Reproduce with `MENUDET_WORK_DIR` set to the approved temporary directory: +`conda run -n blosc2 python -m tools.menudet_jit_interleaved --report +plans/menudet-jit-interleaved.json`. diff --git a/plans/menudet-jit-batch-qualification.json b/plans/menudet-jit-batch-qualification.json new file mode 100644 index 000000000..f23841151 --- /dev/null +++ b/plans/menudet-jit-batch-qualification.json @@ -0,0 +1,93 @@ +{ + "method": "Fresh cache; all corpus rows compared exactly against serial TCC", + "results": [ + { + "corpus": "arithmetic-v1.1.json", + "backend": "tcc", + "cold_seconds": 26.11020554229617, + "cases": 3193, + "routes": { + "interpreter": 1572, + "jit": 1249, + "none": 372 + }, + "all_rows_identical_to_serial_tcc": true, + "external_compiler_invocations": 0, + "stdout_sha256": "9cce75d605164098987b9e1720e7a097222452eedd28eca115888796602e3946" + }, + { + "corpus": "arithmetic-v1.1.json", + "backend": "gcc", + "cold_seconds": 26.55135566694662, + "cases": 3193, + "routes": { + "interpreter": 1572, + "jit": 1249, + "none": 372 + }, + "all_rows_identical_to_serial_tcc": true, + "external_compiler_invocations": 1, + "stdout_sha256": "9cce75d605164098987b9e1720e7a097222452eedd28eca115888796602e3946" + }, + { + "corpus": "arithmetic-v1.1.json", + "backend": "clang", + "cold_seconds": 25.985748291946948, + "cases": 3193, + "routes": { + "interpreter": 1572, + "jit": 1249, + "none": 372 + }, + "all_rows_identical_to_serial_tcc": true, + "external_compiler_invocations": 1, + "stdout_sha256": "9cce75d605164098987b9e1720e7a097222452eedd28eca115888796602e3946" + }, + { + "corpus": "functions-v1.1.json", + "backend": "tcc", + "cold_seconds": 1.047117707785219, + "cases": 1154, + "routes": { + "none": 227, + "jit": 135, + "interpreter": 792 + }, + "all_rows_identical_to_serial_tcc": true, + "external_compiler_invocations": 0, + "stdout_sha256": "a3bba03ea302bf8fc973bbedceeec850446309e4ed02086802f5a21165cda885" + }, + { + "corpus": "functions-v1.1.json", + "backend": "gcc", + "cold_seconds": 1.6251765843480825, + "cases": 1154, + "routes": { + "none": 227, + "jit": 135, + "interpreter": 792 + }, + "all_rows_identical_to_serial_tcc": true, + "external_compiler_invocations": 1, + "stdout_sha256": "a3bba03ea302bf8fc973bbedceeec850446309e4ed02086802f5a21165cda885" + }, + { + "corpus": "functions-v1.1.json", + "backend": "clang", + "cold_seconds": 1.1084123328328133, + "cases": 1154, + "routes": { + "none": 227, + "jit": 135, + "interpreter": 792 + }, + "all_rows_identical_to_serial_tcc": true, + "external_compiler_invocations": 1, + "stdout_sha256": "a3bba03ea302bf8fc973bbedceeec850446309e4ed02086802f5a21165cda885" + } + ], + "compiler_versions": { + "gcc": "gcc-16 (Homebrew GCC 16.2.0) 16.2.0\nCopyright (C) 2026 Free Software Foundation, Inc.\nThis is free software; see the source for copying conditions. There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n", + "clang": "Apple clang version 21.0.0 (clang-2100.3.34.2)\nTarget: arm64-apple-darwin25.6.0\nThread model: posix\nInstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin\n" + } +} diff --git a/plans/menudet-jit-benchmarks.json b/plans/menudet-jit-benchmarks.json new file mode 100644 index 000000000..355cc27e5 --- /dev/null +++ b/plans/menudet-jit-benchmarks.json @@ -0,0 +1,2125 @@ +{ + "platform": "macOS-26.6.2-arm64-arm-64bit-Mach-O", + "numpy": "2.5.3", + "rows": [ + { + "route": "interpreter", + "workload": "affine", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": 0.034292, + "first_ms": 0.0665, + "warm_median_ms": 0.038375, + "warm_samples_ms": [ + 0.042167, + 0.038375, + 0.038333 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "interpreter", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "affine", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": 2.862584, + "first_ms": 0.0475, + "warm_median_ms": 0.007459, + "warm_samples_ms": [ + 0.015, + 0.01025, + 0.008333, + 0.0075, + 0.007459, + 0.007125, + 0.006958, + 0.007084, + 0.006792 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "affine", + "dtype": "float32", + "size": 8, + "api": "array", + "compile_ms": 2.850834, + "first_ms": 0.04925, + "warm_median_ms": 0.00625, + "warm_samples_ms": [ + 0.017708, + 0.01025, + 0.00725, + 0.006542, + 0.00625, + 0.005625, + 0.005375, + 0.005334, + 0.005083 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "affine", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": 404.421125, + "first_ms": 0.323417, + "warm_median_ms": 0.048166, + "warm_samples_ms": [ + 0.087334, + 0.057, + 0.049834, + 0.048166, + 0.048625, + 0.047667, + 0.047291, + 0.047375, + 0.046709 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "affine", + "dtype": "float32", + "size": 8, + "api": "array", + "compile_ms": 397.949875, + "first_ms": 0.442875, + "warm_median_ms": 0.039542, + "warm_samples_ms": [ + 0.103209, + 0.052959, + 0.039542, + 0.037709, + 0.036708, + 0.037958, + 0.040375, + 0.040625, + 0.03325 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numpy", + "workload": "affine", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": null, + "first_ms": 0.011, + "warm_median_ms": 0.001375, + "warm_samples_ms": [ + 0.002417, + 0.001583, + 0.001417, + 0.001542, + 0.001334, + 0.001375, + 0.001333, + 0.001334, + 0.001291 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numpy", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numexpr", + "workload": "affine", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": null, + "first_ms": 0.325417, + "warm_median_ms": 0.004667, + "warm_samples_ms": [ + 0.017416, + 0.008375, + 0.005791, + 0.005208, + 0.004667, + 0.004417, + 0.00425, + 0.004042, + 0.003958 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numexpr", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "interpreter", + "workload": "polynomial", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": 0.03, + "first_ms": 0.063, + "warm_median_ms": 0.031584, + "warm_samples_ms": [ + 0.035708, + 0.031584, + 0.029417 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "interpreter", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "polynomial", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": 2.80075, + "first_ms": 0.048792, + "warm_median_ms": 0.006583, + "warm_samples_ms": [ + 0.014334, + 0.009416, + 0.00725, + 0.006667, + 0.006583, + 0.006334, + 0.00625, + 0.006167, + 0.005917 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "polynomial", + "dtype": "float32", + "size": 8, + "api": "array", + "compile_ms": 2.736375, + "first_ms": 0.0445, + "warm_median_ms": 0.006667, + "warm_samples_ms": [ + 0.016834, + 0.010083, + 0.007625, + 0.007042, + 0.006667, + 0.006209, + 0.006084, + 0.006, + 0.005917 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "polynomial", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": 399.482, + "first_ms": 0.32025, + "warm_median_ms": 0.048333, + "warm_samples_ms": [ + 0.084792, + 0.058833, + 0.049792, + 0.048333, + 0.048333, + 0.047583, + 0.046792, + 0.046833, + 0.04625 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "polynomial", + "dtype": "float32", + "size": 8, + "api": "array", + "compile_ms": 391.360166, + "first_ms": 0.457291, + "warm_median_ms": 0.044917, + "warm_samples_ms": [ + 0.128458, + 0.06775, + 0.051584, + 0.048667, + 0.044917, + 0.041292, + 0.041333, + 0.0415, + 0.040458 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numpy", + "workload": "polynomial", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": null, + "first_ms": 0.0055, + "warm_median_ms": 0.000584, + "warm_samples_ms": [ + 0.001333, + 0.000833, + 0.000625, + 0.000709, + 0.000584, + 0.000583, + 0.000583, + 0.000583, + 0.000584 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numpy", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numexpr", + "workload": "polynomial", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": null, + "first_ms": 0.28025, + "warm_median_ms": 0.004458, + "warm_samples_ms": [ + 0.015167, + 0.007834, + 0.0055, + 0.004958, + 0.004458, + 0.004208, + 0.00425, + 0.004042, + 0.003958 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numexpr", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "interpreter", + "workload": "where", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": 0.035833, + "first_ms": 0.070708, + "warm_median_ms": 0.03975, + "warm_samples_ms": [ + 0.046625, + 0.03975, + 0.039333 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "interpreter", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "where", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": 2.895375, + "first_ms": 0.048125, + "warm_median_ms": 0.0075, + "warm_samples_ms": [ + 0.015042, + 0.01025, + 0.008292, + 0.007542, + 0.0075, + 0.007208, + 0.007083, + 0.007125, + 0.00675 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "where", + "dtype": "float32", + "size": 8, + "api": "array", + "compile_ms": 2.872708, + "first_ms": 0.046375, + "warm_median_ms": 0.006542, + "warm_samples_ms": [ + 0.017334, + 0.010125, + 0.007625, + 0.007167, + 0.006542, + 0.006125, + 0.006125, + 0.005916, + 0.005833 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "where", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": 396.970042, + "first_ms": 0.364875, + "warm_median_ms": 0.047583, + "warm_samples_ms": [ + 0.074959, + 0.055375, + 0.049125, + 0.048083, + 0.047583, + 0.047084, + 0.046292, + 0.046333, + 0.045625 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "where", + "dtype": "float32", + "size": 8, + "api": "array", + "compile_ms": 396.20275, + "first_ms": 0.37425, + "warm_median_ms": 0.042125, + "warm_samples_ms": [ + 0.091042, + 0.054584, + 0.044625, + 0.043625, + 0.042125, + 0.040292, + 0.040208, + 0.040209, + 0.03975 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numpy", + "workload": "where", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": null, + "first_ms": 0.022208, + "warm_median_ms": 0.001584, + "warm_samples_ms": [ + 0.003417, + 0.002084, + 0.001792, + 0.001791, + 0.001584, + 0.001542, + 0.0015, + 0.001459, + 0.001458 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numpy", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numexpr", + "workload": "where", + "dtype": "float32", + "size": 8, + "api": "flat", + "compile_ms": null, + "first_ms": 0.378709, + "warm_median_ms": 0.0045, + "warm_samples_ms": [ + 0.015417, + 0.008333, + 0.005625, + 0.00525, + 0.0045, + 0.0045, + 0.004083, + 0.004, + 0.003916 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numexpr", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "interpreter", + "workload": "affine", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": 0.036875, + "first_ms": 0.081875, + "warm_median_ms": 0.039, + "warm_samples_ms": [ + 0.048834, + 0.039, + 0.03675 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "interpreter", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "affine", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": 2.923916, + "first_ms": 0.054458, + "warm_median_ms": 0.007333, + "warm_samples_ms": [ + 0.015375, + 0.0105, + 0.008125, + 0.007417, + 0.007333, + 0.006333, + 0.006166, + 0.006084, + 0.006084 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "affine", + "dtype": "float64", + "size": 8, + "api": "array", + "compile_ms": 2.84575, + "first_ms": 0.052083, + "warm_median_ms": 0.005875, + "warm_samples_ms": [ + 0.015209, + 0.009, + 0.006709, + 0.00625, + 0.005875, + 0.0055, + 0.005417, + 0.005208, + 0.005166 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "affine", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": 394.854167, + "first_ms": 0.3645, + "warm_median_ms": 0.046667, + "warm_samples_ms": [ + 0.076083, + 0.055125, + 0.048083, + 0.046667, + 0.0475, + 0.046417, + 0.045792, + 0.045167, + 0.045375 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "affine", + "dtype": "float64", + "size": 8, + "api": "array", + "compile_ms": 390.877916, + "first_ms": 0.377417, + "warm_median_ms": 0.048792, + "warm_samples_ms": [ + 0.132334, + 0.073917, + 0.055875, + 0.05225, + 0.048792, + 0.046416, + 0.043167, + 0.044417, + 0.042125 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numpy", + "workload": "affine", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": null, + "first_ms": 0.013375, + "warm_median_ms": 0.001208, + "warm_samples_ms": [ + 0.002125, + 0.001458, + 0.00125, + 0.001375, + 0.001208, + 0.001208, + 0.001208, + 0.001208, + 0.001208 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numpy", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numexpr", + "workload": "affine", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": null, + "first_ms": 0.268959, + "warm_median_ms": 0.005125, + "warm_samples_ms": [ + 0.015792, + 0.008792, + 0.006041, + 0.005541, + 0.005125, + 0.005084, + 0.00475, + 0.004542, + 0.004333 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numexpr", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "interpreter", + "workload": "polynomial", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": 0.030125, + "first_ms": 0.068542, + "warm_median_ms": 0.035167, + "warm_samples_ms": [ + 0.03975, + 0.035167, + 0.03275 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "interpreter", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "polynomial", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": 2.839208, + "first_ms": 0.04725, + "warm_median_ms": 0.008459, + "warm_samples_ms": [ + 0.018875, + 0.010875, + 0.008291, + 0.006792, + 0.00675, + 0.008459, + 0.008792, + 0.008667, + 0.008459 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "polynomial", + "dtype": "float64", + "size": 8, + "api": "array", + "compile_ms": 2.856208, + "first_ms": 0.049166, + "warm_median_ms": 0.006667, + "warm_samples_ms": [ + 0.016792, + 0.010333, + 0.0075, + 0.007, + 0.006667, + 0.006166, + 0.006041, + 0.006, + 0.005833 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "polynomial", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": 395.735875, + "first_ms": 0.088458, + "warm_median_ms": 0.008959, + "warm_samples_ms": [ + 0.021875, + 0.013292, + 0.010459, + 0.009083, + 0.008959, + 0.008583, + 0.00825, + 0.008209, + 0.008084 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "polynomial", + "dtype": "float64", + "size": 8, + "api": "array", + "compile_ms": 394.745417, + "first_ms": 0.415667, + "warm_median_ms": 0.041792, + "warm_samples_ms": [ + 0.0875, + 0.052917, + 0.043208, + 0.042583, + 0.041792, + 0.039292, + 0.039167, + 0.039458, + 0.038542 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numpy", + "workload": "polynomial", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": null, + "first_ms": 0.003125, + "warm_median_ms": 0.000625, + "warm_samples_ms": [ + 0.001334, + 0.000792, + 0.000667, + 0.000708, + 0.000584, + 0.000625, + 0.000583, + 0.000625, + 0.000583 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numpy", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numexpr", + "workload": "polynomial", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": null, + "first_ms": 0.228083, + "warm_median_ms": 0.004834, + "warm_samples_ms": [ + 0.01375, + 0.0075, + 0.005375, + 0.005084, + 0.004583, + 0.004542, + 0.004834, + 0.004666, + 0.004375 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numexpr", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "interpreter", + "workload": "where", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": 0.036041, + "first_ms": 0.064291, + "warm_median_ms": 0.036708, + "warm_samples_ms": [ + 0.039084, + 0.035125, + 0.036708 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "interpreter", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "where", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": 2.728875, + "first_ms": 0.057208, + "warm_median_ms": 0.007541, + "warm_samples_ms": [ + 0.015292, + 0.010708, + 0.00825, + 0.007667, + 0.007541, + 0.007125, + 0.006666, + 0.006958, + 0.006709 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "where", + "dtype": "float64", + "size": 8, + "api": "array", + "compile_ms": 2.861375, + "first_ms": 0.043083, + "warm_median_ms": 0.006125, + "warm_samples_ms": [ + 0.015458, + 0.009208, + 0.007, + 0.006459, + 0.005833, + 0.005583, + 0.005792, + 0.006125, + 0.005834 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "where", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": 398.998291, + "first_ms": 0.391875, + "warm_median_ms": 0.058917, + "warm_samples_ms": [ + 0.101417, + 0.074625, + 0.058917, + 0.05425, + 0.054333, + 0.065875, + 0.059042, + 0.052042, + 0.050417 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "where", + "dtype": "float64", + "size": 8, + "api": "array", + "compile_ms": 395.023625, + "first_ms": 0.375959, + "warm_median_ms": 0.042584, + "warm_samples_ms": [ + 0.095083, + 0.059, + 0.046292, + 0.04425, + 0.042584, + 0.041625, + 0.0415, + 0.041166, + 0.041542 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numpy", + "workload": "where", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": null, + "first_ms": 0.019083, + "warm_median_ms": 0.001625, + "warm_samples_ms": [ + 0.003666, + 0.00225, + 0.001833, + 0.001959, + 0.001625, + 0.001625, + 0.001625, + 0.001584, + 0.001542 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numpy", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numexpr", + "workload": "where", + "dtype": "float64", + "size": 8, + "api": "flat", + "compile_ms": null, + "first_ms": 0.292791, + "warm_median_ms": 0.00475, + "warm_samples_ms": [ + 0.016, + 0.00925, + 0.006458, + 0.00525, + 0.00475, + 0.004417, + 0.004291, + 0.004042, + 0.003958 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numexpr", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "interpreter", + "workload": "affine", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": 0.03475, + "first_ms": 1050.60125, + "warm_median_ms": 1051.614042, + "warm_samples_ms": [ + 1053.169708, + 1051.614042, + 1051.420375 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "interpreter", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "affine", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": 2.912709, + "first_ms": 0.619542, + "warm_median_ms": 0.528667, + "warm_samples_ms": [ + 0.582208, + 0.534916, + 0.528667, + 0.527375, + 0.527334, + 0.535375, + 0.535458, + 0.527167, + 0.527 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "affine", + "dtype": "float32", + "size": 262144, + "api": "array", + "compile_ms": 2.911792, + "first_ms": 0.632292, + "warm_median_ms": 0.55525, + "warm_samples_ms": [ + 0.603084, + 0.550166, + 0.552416, + 0.546375, + 0.551, + 0.55525, + 0.562125, + 0.569833, + 0.569875 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "affine", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": 393.995833, + "first_ms": 1.736458, + "warm_median_ms": 0.779375, + "warm_samples_ms": [ + 1.310792, + 1.00975, + 0.875625, + 0.76675, + 0.80775, + 0.776417, + 0.779375, + 0.69775, + 0.636833 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "affine", + "dtype": "float32", + "size": 262144, + "api": "array", + "compile_ms": 391.663958, + "first_ms": 2.48025, + "warm_median_ms": 1.052458, + "warm_samples_ms": [ + 1.938166, + 1.915583, + 1.469125, + 1.059833, + 1.052458, + 1.022875, + 1.025917, + 0.8535, + 0.801875 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numpy", + "workload": "affine", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": null, + "first_ms": 0.261667, + "warm_median_ms": 0.075458, + "warm_samples_ms": [ + 0.137625, + 0.072125, + 0.071458, + 0.075458, + 0.117459, + 0.075458, + 0.075458, + 0.071541, + 0.120583 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numpy", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numexpr", + "workload": "affine", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": null, + "first_ms": 0.598958, + "warm_median_ms": 0.2885, + "warm_samples_ms": [ + 0.343167, + 0.28925, + 0.292292, + 0.2855, + 0.28425, + 0.288625, + 0.2885, + 0.283542, + 0.2835 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numexpr", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "interpreter", + "workload": "polynomial", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": 0.026875, + "first_ms": 786.329791, + "warm_median_ms": 788.177583, + "warm_samples_ms": [ + 840.831, + 788.177583, + 784.291292 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "interpreter", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "polynomial", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": 2.889458, + "first_ms": 0.595792, + "warm_median_ms": 0.515209, + "warm_samples_ms": [ + 0.589041, + 0.517792, + 0.515209, + 0.514042, + 0.513292, + 0.515834, + 0.510125, + 0.519583, + 0.512875 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "polynomial", + "dtype": "float32", + "size": 262144, + "api": "array", + "compile_ms": 2.855666, + "first_ms": 0.640375, + "warm_median_ms": 0.5265, + "warm_samples_ms": [ + 0.595, + 0.530084, + 0.5265, + 0.534167, + 0.524833, + 0.526291, + 0.5235, + 0.526084, + 0.5265 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "polynomial", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": 392.267541, + "first_ms": 1.333958, + "warm_median_ms": 0.428083, + "warm_samples_ms": [ + 0.868958, + 0.58475, + 0.587416, + 0.520375, + 0.428083, + 0.420209, + 0.414708, + 0.411166, + 0.3925 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "polynomial", + "dtype": "float32", + "size": 262144, + "api": "array", + "compile_ms": 391.452166, + "first_ms": 1.322833, + "warm_median_ms": 0.697458, + "warm_samples_ms": [ + 1.046209, + 0.721834, + 1.178958, + 0.703458, + 0.644875, + 0.667625, + 0.64525, + 0.697458, + 0.619292 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numpy", + "workload": "polynomial", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": null, + "first_ms": 0.255791, + "warm_median_ms": 0.096916, + "warm_samples_ms": [ + 0.1055, + 0.079042, + 0.096916, + 0.075375, + 0.098541, + 0.074875, + 0.132583, + 0.0695, + 0.111291 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numpy", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numexpr", + "workload": "polynomial", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": null, + "first_ms": 0.517916, + "warm_median_ms": 0.217458, + "warm_samples_ms": [ + 0.295459, + 0.209, + 0.2115, + 0.208209, + 0.218458, + 0.202292, + 0.22675, + 0.220542, + 0.217458 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numexpr", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "interpreter", + "workload": "where", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": 0.041458, + "first_ms": 994.01125, + "warm_median_ms": 922.938458, + "warm_samples_ms": [ + 926.224958, + 920.162791, + 922.938458 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "interpreter", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "where", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": 2.864625, + "first_ms": 1.072042, + "warm_median_ms": 1.037542, + "warm_samples_ms": [ + 1.057333, + 1.020334, + 1.038708, + 1.037542, + 1.056333, + 1.008625, + 1.005041, + 1.053833, + 1.003291 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "where", + "dtype": "float32", + "size": 262144, + "api": "array", + "compile_ms": 2.715209, + "first_ms": 1.105708, + "warm_median_ms": 1.031792, + "warm_samples_ms": [ + 1.088792, + 1.032208, + 1.018958, + 1.041833, + 1.117625, + 1.031792, + 1.019875, + 1.023709, + 1.025792 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "where", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": 387.88375, + "first_ms": 3.370209, + "warm_median_ms": 1.811833, + "warm_samples_ms": [ + 2.767916, + 2.082458, + 2.012541, + 1.811833, + 1.801583, + 1.83775, + 1.58975, + 1.600917, + 1.189792 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "where", + "dtype": "float32", + "size": 262144, + "api": "array", + "compile_ms": 393.531375, + "first_ms": 1.557417, + "warm_median_ms": 1.159, + "warm_samples_ms": [ + 0.828875, + 0.652667, + 1.237875, + 1.159, + 1.456459, + 0.934375, + 1.31925, + 0.946209, + 1.225541 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numpy", + "workload": "where", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": null, + "first_ms": 0.430459, + "warm_median_ms": 0.245167, + "warm_samples_ms": [ + 0.273125, + 0.238125, + 0.24475, + 0.239625, + 0.243709, + 0.292625, + 0.245167, + 0.261708, + 0.289167 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numpy", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numexpr", + "workload": "where", + "dtype": "float32", + "size": 262144, + "api": "flat", + "compile_ms": null, + "first_ms": 0.7245, + "warm_median_ms": 0.360541, + "warm_samples_ms": [ + 0.405042, + 0.3405, + 0.349917, + 0.353958, + 0.361, + 0.360541, + 0.355375, + 0.362708, + 0.363459 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numexpr", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "interpreter", + "workload": "affine", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": 0.034583, + "first_ms": 1065.795584, + "warm_median_ms": 1059.036666, + "warm_samples_ms": [ + 1059.036666, + 1065.941625, + 1050.830833 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "interpreter", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "affine", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": 2.727292, + "first_ms": 0.685459, + "warm_median_ms": 0.644542, + "warm_samples_ms": [ + 0.650125, + 0.64375, + 0.646791, + 0.658375, + 0.658291, + 0.633, + 0.632458, + 0.644542, + 0.627083 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "affine", + "dtype": "float64", + "size": 262144, + "api": "array", + "compile_ms": 2.910667, + "first_ms": 0.704167, + "warm_median_ms": 0.655125, + "warm_samples_ms": [ + 0.673292, + 0.672959, + 0.667917, + 0.661708, + 0.652708, + 0.655125, + 0.638084, + 0.631792, + 0.634416 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "affine", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": 388.969, + "first_ms": 2.007625, + "warm_median_ms": 0.877709, + "warm_samples_ms": [ + 1.232125, + 1.059084, + 1.041791, + 0.963542, + 0.844083, + 0.8735, + 0.877709, + 0.850375, + 0.824916 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "affine", + "dtype": "float64", + "size": 262144, + "api": "array", + "compile_ms": 404.233792, + "first_ms": 3.080041, + "warm_median_ms": 1.352625, + "warm_samples_ms": [ + 1.606625, + 1.431333, + 1.360958, + 1.387291, + 1.352625, + 1.105667, + 1.069709, + 1.063459, + 1.15 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numpy", + "workload": "affine", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": null, + "first_ms": 0.48425, + "warm_median_ms": 0.305375, + "warm_samples_ms": [ + 0.390542, + 0.321541, + 0.305375, + 0.33775, + 0.285292, + 0.27325, + 0.2815, + 0.292167, + 0.326042 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numpy", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numexpr", + "workload": "affine", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": null, + "first_ms": 0.687375, + "warm_median_ms": 0.352958, + "warm_samples_ms": [ + 0.360333, + 0.335917, + 0.334708, + 0.352958, + 0.377292, + 0.374292, + 0.351791, + 0.352833, + 0.361584 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numexpr", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "interpreter", + "workload": "polynomial", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": 0.027166, + "first_ms": 793.841708, + "warm_median_ms": 794.27775, + "warm_samples_ms": [ + 795.3735, + 794.27775, + 792.249083 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "interpreter", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "polynomial", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": 2.893291, + "first_ms": 0.727084, + "warm_median_ms": 0.642708, + "warm_samples_ms": [ + 0.669084, + 0.611542, + 0.656167, + 0.641291, + 0.642708, + 0.617709, + 0.626167, + 0.648875, + 0.672333 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "polynomial", + "dtype": "float64", + "size": 262144, + "api": "array", + "compile_ms": 2.772542, + "first_ms": 0.733125, + "warm_median_ms": 0.679792, + "warm_samples_ms": [ + 0.679792, + 0.67175, + 0.700208, + 0.643667, + 0.638792, + 0.643584, + 0.684, + 0.689667, + 0.682459 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "polynomial", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": 372.284041, + "first_ms": 0.440209, + "warm_median_ms": 0.181917, + "warm_samples_ms": [ + 0.196208, + 0.179125, + 0.175916, + 0.16025, + 0.189125, + 0.18075, + 0.181917, + 0.200583, + 0.208459 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "polynomial", + "dtype": "float64", + "size": 262144, + "api": "array", + "compile_ms": 390.369, + "first_ms": 1.921792, + "warm_median_ms": 0.80625, + "warm_samples_ms": [ + 1.079792, + 0.737375, + 0.809791, + 0.80625, + 0.732833, + 0.727625, + 0.815542, + 0.624625, + 1.103417 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numpy", + "workload": "polynomial", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": null, + "first_ms": 0.434833, + "warm_median_ms": 0.255833, + "warm_samples_ms": [ + 0.324834, + 0.255792, + 0.257167, + 0.251166, + 0.277, + 0.25825, + 0.255833, + 0.249709, + 0.255542 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numpy", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numexpr", + "workload": "polynomial", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": null, + "first_ms": 0.569209, + "warm_median_ms": 0.317917, + "warm_samples_ms": [ + 0.314334, + 0.311292, + 0.355541, + 0.32475, + 0.309167, + 0.309083, + 0.318083, + 0.317917, + 0.3565 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numexpr", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "interpreter", + "workload": "where", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": 0.041542, + "first_ms": 928.556208, + "warm_median_ms": 936.569583, + "warm_samples_ms": [ + 936.569583, + 936.018625, + 940.516042 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "interpreter", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "where", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": 2.901, + "first_ms": 1.131083, + "warm_median_ms": 1.034792, + "warm_samples_ms": [ + 1.084583, + 1.028167, + 1.031209, + 1.030042, + 1.028541, + 1.052833, + 1.061334, + 1.034792, + 1.072708 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "tcc", + "workload": "where", + "dtype": "float64", + "size": 262144, + "api": "array", + "compile_ms": 2.913459, + "first_ms": 1.192833, + "warm_median_ms": 1.072584, + "warm_samples_ms": [ + 1.136958, + 1.1005, + 1.055708, + 1.092583, + 1.072584, + 1.074583, + 1.041875, + 1.042541, + 1.041833 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "tcc", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "where", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": 393.415458, + "first_ms": 5.772875, + "warm_median_ms": 2.226167, + "warm_samples_ms": [ + 3.633083, + 3.149583, + 2.6385, + 2.488042, + 2.226167, + 2.114667, + 2.018958, + 1.938042, + 1.908167 + ], + "has_jit": true, + "threads": 1, + "tile_items": null, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "gcc", + "workload": "where", + "dtype": "float64", + "size": 262144, + "api": "array", + "compile_ms": 388.220458, + "first_ms": 6.016667, + "warm_median_ms": 2.161167, + "warm_samples_ms": [ + 3.877458, + 3.063167, + 2.953042, + 2.488583, + 2.105917, + 2.161167, + 1.739916, + 2.08425, + 1.241042 + ], + "has_jit": true, + "threads": 1, + "tile_items": 1024, + "compiler": "/opt/homebrew/bin/gcc-16", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numpy", + "workload": "where", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": null, + "first_ms": 0.641875, + "warm_median_ms": 0.507084, + "warm_samples_ms": [ + 0.51875, + 0.5305, + 0.535459, + 0.505625, + 0.502916, + 0.519417, + 0.507084, + 0.490166, + 0.504333 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numpy", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "route": "numexpr", + "workload": "where", + "dtype": "float64", + "size": 262144, + "api": "flat", + "compile_ms": null, + "first_ms": 0.768708, + "warm_median_ms": 0.46875, + "warm_samples_ms": [ + 0.466583, + 0.504709, + 0.46875, + 0.48625, + 0.482208, + 0.466708, + 0.475791, + 0.448, + 0.451083 + ], + "has_jit": false, + "threads": 1, + "tile_items": null, + "compiler": "numexpr", + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + } + ], + "limitations": [ + "C-contiguous finite workloads; selected-lane diagnostics qualified separately.", + "No explicit SIMD added; GCC may autovectorize strict loops.", + "Native comparison bridge retains interpreter comparison semantics.", + "Fresh-process artifact compilation includes metadata inference, not export.", + "Compilation/first/warm separate; no process-wide speedup claim." + ] +} diff --git a/plans/menudet-jit-expanded-conformance.json b/plans/menudet-jit-expanded-conformance.json new file mode 100644 index 000000000..efc880d33 --- /dev/null +++ b/plans/menudet-jit-expanded-conformance.json @@ -0,0 +1,24 @@ +{ + "backend": "tcc", + "requested_jit": true, + "corpora": { + "arithmetic-v1.1.json": { + "cases": 3193, + "routes": { + "interpreter": 1572, + "jit": 1249, + "none": 372 + }, + "all_reference_match": true + }, + "functions-v1.1.json": { + "cases": 1154, + "routes": { + "none": 227, + "jit": 135, + "interpreter": 792 + }, + "all_reference_match": true + } + } +} diff --git a/plans/menudet-jit-expanded-interleaved.json b/plans/menudet-jit-expanded-interleaved.json new file mode 100644 index 000000000..55b81b8a2 --- /dev/null +++ b/plans/menudet-jit-expanded-interleaved.json @@ -0,0 +1,16663 @@ +{ + "platform": "macOS-26.6.2-arm64-arm-64bit-Mach-O", + "numpy": "2.5.3", + "numexpr": "2.14.2", + "size": 262144, + "dtype": "float64", + "api": "flat", + "numexpr_threads": 1, + "technique": "Rotating workload/backend order; untimed warm-up; identical shared buffers", + "samples_per_process": { + "interpreter": 3, + "other_backends": 30 + }, + "compiler_versions": { + "gcc": "gcc-16 (Homebrew GCC 16.2.0) 16.2.0\nCopyright (C) 2026 Free Software Foundation, Inc.\nThis is free software; see the source for copying conditions. There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n", + "clang": "Apple clang version 21.0.0 (clang-2100.3.34.2)\nTarget: arm64-apple-darwin25.6.0\nThread model: posix\nInstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin\n" + }, + "summary": [ + { + "workload": "affine", + "backend": "interpreter", + "median_of_process_medians_ms": 1068.612583, + "process_medians_ms": [ + 1068.612583, + 1065.165792, + 1068.567417, + 1068.988083, + 1072.788792 + ] + }, + { + "workload": "affine", + "backend": "tcc", + "median_of_process_medians_ms": 0.674125, + "process_medians_ms": [ + 0.673271, + 0.678708, + 0.674125, + 0.6668540000000001, + 0.6752505 + ] + }, + { + "workload": "affine", + "backend": "gcc", + "median_of_process_medians_ms": 0.313875, + "process_medians_ms": [ + 0.303875, + 0.318396, + 0.3151665, + 0.313875, + 0.3015835 + ] + }, + { + "workload": "affine", + "backend": "clang", + "median_of_process_medians_ms": 0.273563, + "process_medians_ms": [ + 0.2646665, + 0.27479149999999997, + 0.2810215, + 0.273563, + 0.27197899999999997 + ] + }, + { + "workload": "affine", + "backend": "numpy", + "median_of_process_medians_ms": 0.3437085, + "process_medians_ms": [ + 0.3477085, + 0.33610450000000003, + 0.367417, + 0.3437085, + 0.338375 + ] + }, + { + "workload": "affine", + "backend": "numexpr", + "median_of_process_medians_ms": 0.400229, + "process_medians_ms": [ + 0.400229, + 0.394146, + 0.40102099999999996, + 0.4079795, + 0.39660399999999996 + ] + }, + { + "workload": "polynomial", + "backend": "interpreter", + "median_of_process_medians_ms": 803.096583, + "process_medians_ms": [ + 804.004, + 801.128792, + 802.63225, + 803.941083, + 803.096583 + ] + }, + { + "workload": "polynomial", + "backend": "tcc", + "median_of_process_medians_ms": 0.6832914999999999, + "process_medians_ms": [ + 0.6816875, + 0.686771, + 0.6832914999999999, + 0.653875, + 0.6857495 + ] + }, + { + "workload": "polynomial", + "backend": "gcc", + "median_of_process_medians_ms": 0.16925, + "process_medians_ms": [ + 0.166521, + 0.16925, + 0.172146, + 0.167125, + 0.1714375 + ] + }, + { + "workload": "polynomial", + "backend": "clang", + "median_of_process_medians_ms": 0.1448335, + "process_medians_ms": [ + 0.139708, + 0.1483335, + 0.1448335, + 0.1384795, + 0.1450415 + ] + }, + { + "workload": "polynomial", + "backend": "numpy", + "median_of_process_medians_ms": 0.340917, + "process_medians_ms": [ + 0.350771, + 0.340917, + 0.37293750000000003, + 0.339854, + 0.340021 + ] + }, + { + "workload": "polynomial", + "backend": "numexpr", + "median_of_process_medians_ms": 0.333104, + "process_medians_ms": [ + 0.333042, + 0.34100050000000004, + 0.3499165, + 0.32875, + 0.333104 + ] + }, + { + "workload": "where", + "backend": "interpreter", + "median_of_process_medians_ms": 940.055333, + "process_medians_ms": [ + 940.055333, + 937.34175, + 937.117417, + 940.430416, + 944.2495 + ] + }, + { + "workload": "where", + "backend": "tcc", + "median_of_process_medians_ms": 1.0643125, + "process_medians_ms": [ + 1.0703545, + 1.0643125, + 1.0721875, + 1.058187, + 1.056667 + ] + }, + { + "workload": "where", + "backend": "gcc", + "median_of_process_medians_ms": 0.383229, + "process_medians_ms": [ + 0.3795, + 0.379854, + 0.3859375, + 0.38858349999999997, + 0.383229 + ] + }, + { + "workload": "where", + "backend": "clang", + "median_of_process_medians_ms": 0.341, + "process_medians_ms": [ + 0.3328545, + 0.3496665, + 0.34375, + 0.331187, + 0.341 + ] + }, + { + "workload": "where", + "backend": "numpy", + "median_of_process_medians_ms": 0.596292, + "process_medians_ms": [ + 0.5714794999999999, + 0.596292, + 0.622292, + 0.5949789999999999, + 0.6026665 + ] + }, + { + "workload": "where", + "backend": "numexpr", + "median_of_process_medians_ms": 0.480417, + "process_medians_ms": [ + 0.468042, + 0.4967085, + 0.480417, + 0.47891700000000004, + 0.4844165 + ] + } + ], + "processes": [ + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1066.856375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.79225 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.297958 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.252875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.397291 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.456708 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 802.660583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.725167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.146542 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.141834 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.374042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.356042 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 940.000083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.247125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.394 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.341041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.705125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.519625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.682417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.1805 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.152458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.377792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.331792 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 804.653375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.147334 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.452333 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.383375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.801792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.569458 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 942.417292 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.771292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.314542 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.274875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.363625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.415375 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1072.267959 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.4785 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.360458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.604417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.562417 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 940.055333 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.10125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.31975 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.261375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.335958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.410292 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1068.612583 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.746375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.175167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.145333 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.391583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.403375 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 804.004 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.722333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.364083 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.400625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.647125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.286083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.247 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.289625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.305125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.63375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.145458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.141041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.557208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.454167 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.122167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.504 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.363625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.373041 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.692041 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.166042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.1425 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.365833 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.576334 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.115417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.4655 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.363833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.685167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.426958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.687084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.302209 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.277375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.336625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.068709 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.3795 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.332542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.579875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.485542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.67 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.300375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.261208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.342291 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.388125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.669292 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.161708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.132292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.305334 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.350208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.306708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.256709 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.316542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.393916 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.694834 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.18 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.148 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.335583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.378125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.667417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.3895 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.352416 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.586875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.4675 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.037333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.128875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.348292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.317958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.68775 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.165333 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.321458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.558292 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.474417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.050875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.38025 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.262208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.34375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.396667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.6965 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.300917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.509792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.483625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.079458 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.378542 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.341666 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.355125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.393917 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.655458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.305916 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.264333 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.304084 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.330834 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.668083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.176291 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.13175 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.380334 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.683458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.317041 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.278 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.352208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.32875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.676667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.17175 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.136666 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.317208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.468584 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.049167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.386166 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.339583 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.579125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.743417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.279417 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.155542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.363833 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.424834 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.065334 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.3795 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.324792 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.557208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.448625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.647959 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.2955 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.25375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.310334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.374958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.361417 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.326125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.502583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.442958 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.01225 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.278084 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.248834 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.304875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.358166 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.635083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.174458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.133458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.557083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.369917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.714875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.277333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.398875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.394709 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.724459 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.310333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.122667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.334917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.334083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.690417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.16875 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.347375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.686958 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.472042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.074 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.457584 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.3945 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.339541 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.689416 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.171875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.134917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.617875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.464 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.083834 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.379209 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.327458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.350584 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.386208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.657 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.305125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.255083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.464167 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.038 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.376666 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.349041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.568417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.399833 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.664709 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.312834 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.294291 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.344833 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.331375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.67275 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.174292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.139458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.364958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.676542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.338292 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.288625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.373167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.503167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.717458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.142084 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.366083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.340875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.050958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.386875 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.324125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.527125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.46575 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.146208 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.115125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.276333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.316041 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.645542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.343958 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.309791 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.486792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.45225 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.017916 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.29725 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.24125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.30875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.406875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.707666 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.341709 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.727584 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.481042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.0655 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.370208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.270583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.358708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.413417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.678541 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.330834 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.139958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.367 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.333625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.682792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.167416 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.355916 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.421958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.705292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.302625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.274667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.357834 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.332459 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.685167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.158042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.146917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.602375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.45775 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.091708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.392667 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.338542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.34425 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.700208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.145958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.121667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.312125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.47225 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.076333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.363875 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.310791 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.574542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.374375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.644959 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.296792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.256666 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.297083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.042834 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.376 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.332375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.560625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.466708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.654417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.29775 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.256917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.307875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.372125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.623042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.156875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.13175 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.288292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.31975 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.3135 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.349458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.478666 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.427541 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.67825 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.163958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.135208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.313584 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.325041 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.670917 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.375833 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.327333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.560375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.464416 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.063166 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.140667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.35325 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.342 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.680958 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.1745 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.34 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.584833 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.485375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.074292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.38975 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.273417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.369417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.408875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.67975 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.297834 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.554041 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.466208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.058458 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.37225 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.321833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.318833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.373375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.64575 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.2835 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.257458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.30025 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.299083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.64125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.14175 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.127333 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.367958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.663667 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.293125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.272834 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.322208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.314167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.654333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.159291 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.127625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.296292 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.5275 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.072 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.393 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.319542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.534917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.666709 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.169667 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.147125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.355084 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.326292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.031083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.372375 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.334542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.530583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.453791 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.650166 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.299125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.265 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.332167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.367542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.339084 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.300208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.4735 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.439458 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.1985 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.401167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.262208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.376125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.420083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.66125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.157292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.122833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.312 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.3275 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.675 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.282916 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.37375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.426959 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.758917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.353208 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.157083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.278917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.325625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.628333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.162625 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.322291 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.546917 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.482667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.127291 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.471958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.387708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.373417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.75475 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.158417 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.142958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.676709 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.488667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.049208 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.377334 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.332208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.3415 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.407625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.658125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.32175 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.268542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.466292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.085792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.367875 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.333167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.588042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.401583 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.652417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.307459 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.272917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.358125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.334834 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.700459 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.216333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.150584 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.361291 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.041042 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 11.421875 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 545.886333 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 372.994459 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.153708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 12.792208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 401.723458 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 342.435708 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.099833 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 12.595833 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 402.269792 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 357.54375 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a0fc14ae069f6d190f6681f661d8ec1d8f7e04db9f5572413d103bf77c4c8ea9" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1067.514292 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.776875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.364042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.300958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.436541 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.46375 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 802.23125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.776083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.217458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.16925 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.381292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.400166 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 936.996417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.170333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.3945 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.342708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.673625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.527083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.712875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.162125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.143292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.308708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.322875 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 797.627583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.1265 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.377958 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.361833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.622417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.519959 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 937.34175 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.753792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.295417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.258208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.472834 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.4775 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1065.165792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.46125 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.372917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.653292 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.52675 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 938.404417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.088792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.329334 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.276 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.38175 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.403375 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1062.749292 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.744792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.157292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.12225 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.352959 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.347792 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 801.128792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.76025 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.366417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.412833 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.690208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.311125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.262292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.352167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.345875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.693792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.172375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.179292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.708917 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.500042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.07725 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.392208 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.337541 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.331584 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.679542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.179459 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.15625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.36125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.483209 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.049417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.365458 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.377083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.582833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.372833 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.676542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.298459 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.265917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.303959 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.027709 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.360417 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.373375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.772959 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.512833 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.725333 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.355625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.271875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.369333 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.394917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.661042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.181458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.1425 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.359334 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.345667 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.327959 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.286791 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.3225 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.399292 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.673666 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.175125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.163209 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.353834 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.342042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.68075 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.41425 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.390958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.62475 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.528833 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.128792 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.163167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.38925 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.364042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.735458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.207041 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.387375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.723459 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.555125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.113125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.428 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.326625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.440542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.432875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.723583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.344375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.745708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.526416 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.115042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.408666 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.373125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.33525 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.366583 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.678958 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.305417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.268667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.309208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.3285 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.695 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.158292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.140708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.403375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.71575 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.3445 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.350417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.393 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.367042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.687042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.155833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.123833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.328 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.47475 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.061708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.37125 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.334666 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.518292 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.708459 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.155625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.124125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.298959 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.333792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.0305 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.38175 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.332833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.527666 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.464042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.7495 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.353791 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.263458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.320959 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.385333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.358791 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.322792 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.572667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.454667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.0505 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.30675 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.274333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.308958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.389959 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.658375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.207667 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.127917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.299375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.319083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.668541 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.249041 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.279375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.357166 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.645291 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.329083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.250166 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.362791 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.36025 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.665834 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.157041 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.343875 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.638583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.476292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.057166 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.371417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.348667 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.333791 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.695833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.16225 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.151542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.591709 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.469459 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.103542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.399 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.349958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.335917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.394042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.703625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.333792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.279458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.493375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.072458 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.384042 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.341084 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.634667 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.39675 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.674334 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.298583 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.279666 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.413542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.34775 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.666541 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.172959 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.147458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.331875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.672042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.302459 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.270208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.336292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.425 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.71425 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.189625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.156917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.357167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.354375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.061042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.377916 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.364541 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.621958 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.474208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.166125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.170209 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.36925 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.337792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.678792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.394625 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.347833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.600875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.52175 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.092084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.32175 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.281917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.376416 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.395125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.692125 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.331125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.515542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.472416 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.066917 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.36825 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.294917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.28975 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.372125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.660125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.281791 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.116 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.289209 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.314916 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.677625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.150541 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.28475 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.384 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.678458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.335166 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.263583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.300875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.335416 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.6865 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.160292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.149209 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.572083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.476625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.059917 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.376458 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.374166 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.46325 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.72625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.186958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.153625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.327167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.503791 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.049708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.368416 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.333333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.546084 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.404792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.800709 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.315042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.369792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.335209 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.02775 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.366709 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.349375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.510875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.530709 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.719542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.311 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.353583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.377875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.374417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.720333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.160417 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.125167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.286292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.344542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.303209 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.265125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.32625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.375375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.650875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.158458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.118959 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.289167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.33425 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.740584 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.463291 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.373542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.825333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.515 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.094 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.245958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.397958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.3295 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.673209 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.173083 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.348125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.559 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.507666 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.032416 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.361666 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.263541 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.297375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.372042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.657583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.289083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.545625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.562125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.100291 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.385042 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.359292 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.393583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.39425 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.670292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.330542 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.324708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.374959 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.391917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.735125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.234416 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.153167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.3995 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.677208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.348583 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.286417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.366042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.339959 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.686208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.202875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.222875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.46575 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.506875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.100458 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.399833 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.37425 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.667458 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.710958 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.188542 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.160167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.333167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.356917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.079042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.397875 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.35775 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.573417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.484542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.736083 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.377167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.27525 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.405083 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.400541 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.377792 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.362167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.674125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.490583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.056084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.284542 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.245583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.31225 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.357 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.662458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.145083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.113625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.267375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.313292 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.658792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.267375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.272166 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.366083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.654625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.272916 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.111875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.303166 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.32025 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.680083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.152791 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.326083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.551667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.455042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.054709 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.437792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.364959 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.315208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.668 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.180417 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.140333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.51075 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.456709 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.0245 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.349667 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.326041 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.299958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.370167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.661542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.298291 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.270667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.455792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.0355 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.358417 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.324791 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.537875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.37025 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.774916 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.393667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.276375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.406625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.35525 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.682916 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.152458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.121708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.322542 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.037208 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 6.071333 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 414.930875 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 348.142459 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.072375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 8.579791 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 390.891333 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 368.802041 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.089542 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 13.386375 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 400.594958 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 352.249916 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a0fc14ae069f6d190f6681f661d8ec1d8f7e04db9f5572413d103bf77c4c8ea9" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1068.567417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.753917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.442458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.3935 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.362833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.412292 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 801.582708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.790875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.188875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.15075 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.423 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.362167 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 941.650666 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.168792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.387958 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.345 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.702833 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.532166 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.697959 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.180375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.159 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.380083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.358125 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 802.63225 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.152958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.385333 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.3485 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.645375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.505416 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 937.034083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.768209 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.317041 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.283584 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.358125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.409625 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1066.975625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.508083 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.361292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.633209 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.518292 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 937.117417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.160458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.39125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.275708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.425208 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.41825 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1070.317208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.762709 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.16725 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.143333 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.413084 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.36775 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 802.632792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.786208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.36875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.449667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.702792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.318917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.298666 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.403667 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.334083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.683791 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.170625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.147959 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.550625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.470583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.08425 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.470584 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.358292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.353792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.682792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.174125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.158416 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.379291 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.478875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.101 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.384666 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.337292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.61625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.416584 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.674542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.317625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.283125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.401167 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.066958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.386542 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.36225 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.608042 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.483667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.668459 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.324125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.246083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.321125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.385791 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.642292 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.169708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.371791 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.392166 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.347208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.308792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.276708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.343042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.407125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.681333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.164167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.139792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.341916 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.338458 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.667834 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.366875 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.322 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.583834 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.467792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.049583 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.148708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.35775 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.329458 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.660375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.16475 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.330416 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.580375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.486292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.073833 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.387292 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.295291 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.455208 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.412917 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.712834 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.297667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.71075 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.48075 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.036042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.374917 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.338916 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.427208 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.404417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.70475 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.351083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.263834 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.428042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.353833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.687417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.181417 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.150875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.396709 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.657583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.313292 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.281209 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.380583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.340042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.670208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.172125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.140792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.337 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.476375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.073125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.40175 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.357333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.689834 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.682333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.177709 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.181625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.409708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.392667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.149709 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.404083 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.370042 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.770625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.520541 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.707375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.344625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.302542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.442125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.428625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.434042 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.480042 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.60225 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.501917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.07125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.319458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.277875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.376417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.473167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.724292 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.197458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.1665 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.431375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.355291 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.696208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.284083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.366084 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.408625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.68675 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.323416 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.154667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.359333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.338458 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.696417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.175834 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.355708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.615458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.508459 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.146417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.409625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.379958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.369125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.669208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.176 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.153417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.645167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.460458 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.04675 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.359958 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.319333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.2845 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.390833 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.659834 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.283875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.248958 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.46225 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.05475 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.381416 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.341834 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.578792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.391458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.66075 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.307916 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.257792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.325583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.320292 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.697792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.202167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.125042 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.278917 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.67125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.293458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.259958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.303375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.372125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.648792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.158167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.124083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.293209 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.317959 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.053458 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.367583 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.329709 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.539875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.462208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.150333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.12225 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.289542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.306458 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.638416 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.355583 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.319333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.484459 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.512 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.108833 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.302084 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.2535 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.382708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.438417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.645916 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.333625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.580542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.458625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.042292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.366166 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.300417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.3475 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.394042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.672375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.32 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.153375 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.366584 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.343083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.6925 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.168625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.348375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.399167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.690125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.311458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.280834 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.406792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.418291 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.694458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.184333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.145292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.759416 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.482083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.062333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.381458 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.330209 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.347625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.673917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.184708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.144375 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.344875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.477041 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.053417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.382417 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.342292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.581042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.386958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.673708 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.322542 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.270084 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.384708 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.082417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.391792 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.3425 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.668291 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.489083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.672 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.30125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.293416 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.337958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.384 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.694833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.172167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.1335 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.336917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.379959 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.312083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.367667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.336084 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.38675 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.654417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.15575 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.126167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.298416 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.3165 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.645792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.37975 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.332917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.588417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.452334 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.032208 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.127333 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.290958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.324542 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.675459 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.15475 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.321792 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.49625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.469792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.087416 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.463625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.323542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.335375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.372583 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.663333 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.299166 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.628334 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.474625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.051875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.386583 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.332334 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.317625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.378834 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.649709 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.292 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.258083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.305625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.312584 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.629666 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.223334 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.127166 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.364625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.710583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.406208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.268333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.500667 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.407 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.7355 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.169917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.130166 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.38025 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.472917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.036917 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.42125 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.422875 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.742417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.677958 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.161333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.13525 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.33025 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.332 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.051375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.360041 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.37225 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.75475 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.5045 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.670875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.289667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.291084 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.380417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.405708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.37025 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.352666 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.681583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.485375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.057417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.310125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.267334 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.351458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.390125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.6585 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.170541 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.147417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.35675 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.357417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.7115 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.346875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.405084 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.402875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.702 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.360583 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.13975 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.391083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.352208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.715583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.173625 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.346291 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.644875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.480084 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.116708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.459459 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.502 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.371417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.6815 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.175375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.146167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.808834 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.506334 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.161333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.46325 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.369208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.410375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.415042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.682542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.323291 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.283875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.4735 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.085333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.385042 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.345041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.606542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.39375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.661417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.301958 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.266041 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.387083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.412875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.709166 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.170666 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.142833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.38875 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.045958 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 8.733375 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 522.041084 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 352.134459 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.065917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 11.60725 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 405.706 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 349.649416 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.09775 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 13.59675 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 414.362042 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 347.31575 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a0fc14ae069f6d190f6681f661d8ec1d8f7e04db9f5572413d103bf77c4c8ea9" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1068.988083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.801292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.318333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.287834 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.443209 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.475375 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 801.96775 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.737 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.197375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.139625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.383875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.3445 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 940.430416 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.171958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.401458 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.354834 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.659833 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.523667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.678209 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.174875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.139917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.34975 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.33725 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 804.694208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.188625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.427625 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.400292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.678125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.508542 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 939.886708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.715292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.330792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.293875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.412958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.454292 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1073.221417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.483833 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.331791 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.695208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.494167 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 941.701208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.14425 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.316708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.277209 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.376792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.426833 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1067.897917 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.711083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.180875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.141583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.407167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.355333 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 803.941083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.779583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.360709 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.427958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.684083 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.311375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.261833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.34875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.335167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.652208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.16525 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.141292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.563458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.451208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.1335 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.442125 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.318792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.314833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.636375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.187667 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.179708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.335209 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.474459 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.072333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.367792 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.330583 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.639417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.410417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.7045 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.344583 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.292667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.361541 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.071042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.39325 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.332625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.624125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.503708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.673875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.314416 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.277292 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.343292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.423625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.668083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.186 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.139708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.344959 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.331125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.315875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.273584 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.346625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.43675 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.704875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.246167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.155459 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.375083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.343958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.639083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.370166 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.321625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.594667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.649875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.060833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.138417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.363125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.321792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.663583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.225375 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.367666 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.709375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.473209 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.048708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.37375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.296958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.344125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.422333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.663792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.313 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.54 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.471 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.032375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.361375 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.311292 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.341666 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.38225 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.652125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.3175 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.288209 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.306625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.328167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.67325 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.161375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.131167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.396625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.643041 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.289875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.2495 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.332917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.343208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.655833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.161208 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.132584 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.315833 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.493 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.062875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.394958 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.33025 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.680875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.639416 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.168042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.130667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.379458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.328 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.019208 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.3795 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.327167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.571708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.465458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.654208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.295208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.264417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.353125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.402875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.413708 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.33425 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.597 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.480459 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.028084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.317 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.266958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.38925 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.404542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.667125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.20675 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.134583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.335959 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.333625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.659791 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.257166 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.340625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.414417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.689875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.286834 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.124125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.314333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.324458 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.624541 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.131709 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.300042 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.551041 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.456083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.014833 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.357833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.295542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.309666 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.628333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.137875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.138833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.483416 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.439125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.055541 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.423208 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.32675 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.340625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.416375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.660959 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.313708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.275125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.460541 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.031916 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.386167 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.322125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.694458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.40575 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.666583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.314667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.273542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.38225 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.328416 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.657416 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.173208 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.133042 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.303667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.650125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.293375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.247875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.295625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.38175 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.673084 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.139334 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.114167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.284916 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.324 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.031041 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.364792 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.322416 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.56375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.465084 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.151625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.12525 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.309084 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.297333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.621084 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.365584 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.333292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.576209 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.52225 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.054792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.297167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.253375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.390875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.395791 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.661958 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.335 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.59475 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.484583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.116417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.442208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.263625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.392959 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.387459 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.661208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.314042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.14425 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.360584 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.318625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.648292 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.155959 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.328666 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.409875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.7505 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.366 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.261375 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.359125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.329084 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.638042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.153417 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.129917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.556709 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.459917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.110875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.474667 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.329292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.330916 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.662958 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.159 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.137583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.40475 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.489125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.067375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.397209 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.336375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.660875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.416375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.680666 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.307 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.282542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.334625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.034167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.370875 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.346542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.59275 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.477375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.642375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.2995 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.279292 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.30725 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.426083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.627667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.166208 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.118125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.286625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.327791 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.28875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.261333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.27525 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.391625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.663 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.1685 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.125667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.277834 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.291875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.655542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.3585 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.31725 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.517625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.492292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.113958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.156209 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.392333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.356542 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.68425 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.19875 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.341542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.691583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.52325 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.043542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.391 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.259458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.341791 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.42175 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.66925 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.2985 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.573542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.462542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.044917 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.364458 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.30825 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.263834 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.3785 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.626834 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.338417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.423417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.340458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.338833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.643334 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.146125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.145 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.376584 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.6335 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.284708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.2685 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.329416 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.300375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.639417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.171708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.13775 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.317125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.48475 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.0535 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.399125 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.339709 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.613792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.64975 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.154166 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.140458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.33925 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.320834 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.031417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.374834 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.335333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.63725 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.462125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.638375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.307083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.248542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.304 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.383083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.378125 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.31575 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.594125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.459541 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.142375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.378125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.259208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.378375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.386 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.65225 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.177625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.138542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.3145 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.320542 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.658125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.273917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.318333 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.40775 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.683291 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.319334 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.176625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.418542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.346125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.65025 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.16175 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.320166 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.576375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.4625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.10725 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.460458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.401125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.361375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.690875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.184083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.170208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.679542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.504666 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.070375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.394 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.352584 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.423917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.408209 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.68975 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.304 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.276791 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.482542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.040625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.382292 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.33525 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.595208 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.397167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.669917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.318625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.282459 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.382708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.333958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.651584 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.158666 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.126083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.32375 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.035375 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 6.11925 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 413.085958 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 345.685667 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.17325 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 13.4415 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 400.736541 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 357.97625 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.165375 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 14.633084 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 392.832458 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 356.36075 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a0fc14ae069f6d190f6681f661d8ec1d8f7e04db9f5572413d103bf77c4c8ea9" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1065.7795 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.792792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.369792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.276709 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.3875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.409625 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 802.868042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.852875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.2775 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.147709 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.354708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.390333 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 941.68875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.1015 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.371833 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.341083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.661625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.487042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.667709 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.165625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.141583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.3325 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.326667 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 803.096583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.205792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.442583 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.345417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.680334 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.498375 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 945.536958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.770125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.337208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.307667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.421125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.41625 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1078.574958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.476041 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.343041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.663916 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.488667 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 944.2495 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.178333 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.316792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.265458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.430917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.479208 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1072.788792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.749875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.201083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.154417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.37275 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.38875 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 804.057375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.753917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.400334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.407958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.658125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.293084 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.25575 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.316708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.326834 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.735542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.262708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.144833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.590584 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.509542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.060417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.393708 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.340917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.34 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.655291 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.157125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.140917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.359292 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.459333 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.078167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.439417 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.330083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.649166 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.395375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.682958 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.301417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.275125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.3465 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.053083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.371042 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.359334 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.550375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.4885 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.690417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.305667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.268833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.328334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.40425 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.688292 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.176417 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.12975 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.327625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.334 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.289334 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.254333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.321 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.377583 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.650125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.172084 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.131916 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.332708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.336583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.667416 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.399083 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.324083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.628208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.496 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.037334 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.153125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.345791 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.327 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.683708 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.165542 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.342459 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.569083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.468667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.019292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.382542 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.273625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.369541 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.405958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.700541 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.413625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.592 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.5095 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.089916 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.38225 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.349791 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.342542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.439333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.666542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.306042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.283125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.323792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.329875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.711375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.170791 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.149334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.390625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.694875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.311666 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.279 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.334958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.346625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.732666 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.16725 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.133625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.376291 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.581833 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.084333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.400625 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.374875 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.601917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.691375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.188167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.151667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.340167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.351166 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.078458 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.367167 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.339417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.645209 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.482208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.697083 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.362 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.279292 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.331875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.385584 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.38575 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.345 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.548958 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.4675 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.020458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.298208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.261083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.296125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.397833 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.685583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.148125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.119917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.319417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.329625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.680125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.315083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.3455 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.388375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.676417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.317375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.194 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.40325 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.360625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.68075 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.186208 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.372417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.678708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.495459 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.084125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.394 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.39075 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.332208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.687791 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.17975 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.151 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.610041 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.490875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.038041 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.356375 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.317041 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.390333 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.612458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.669416 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.297834 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.27 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.484916 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.056709 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.36625 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.334 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.612625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.387292 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.660583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.284709 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.268333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.3675 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.328583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.691417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.168291 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.14525 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.320458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.665584 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.286208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.255083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.328875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.424666 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.647583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.166875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.146583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.388875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.331583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.028208 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.366125 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.343458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.588333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.472166 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.170125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.142917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.326 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.331125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.658916 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.36175 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.36125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.583375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.478708 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.05075 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.30175 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.266792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.327875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.384458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.659792 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.337875 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.626792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.471167 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.082125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.379542 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.279583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.341959 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.400209 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.671458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.322042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.213209 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.439584 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.3635 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.683584 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.180459 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.356416 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.394709 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.68575 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.32525 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.286875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.373625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.347792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.719166 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.197875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.156125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.657708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.49325 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.047542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.394292 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.411959 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.348 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.707583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.185833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.163291 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.37325 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.478125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.06275 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.391625 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.339125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.569875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.400792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.702125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.348833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.264042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.425083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.069833 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.391833 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.317458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.564916 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.467625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.6405 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.289167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.25 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.338875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.40475 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.651041 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.153458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.130041 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.290208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.367167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.296083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.27925 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.337875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.382792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.677208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.193166 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.1245 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.339875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.338541 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.73 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.385584 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.355875 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.551916 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.455917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.056625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.148083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.376416 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.317875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.672916 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.188083 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.338333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.566083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.483917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.048542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.396042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.2725 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.318541 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.420417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.684625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.282917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.603416 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.465 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.035125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.362209 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.324083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.31525 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.388625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.674084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.30175 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.290541 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.339875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.325917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.67775 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.181042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.138542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.375167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.647791 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.29025 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.258375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.322666 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.325667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.655875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.157291 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.165958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.416542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.50425 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.054792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.371291 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.336583 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.601875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.690875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.170292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.138917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.331875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.341666 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.027958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.364917 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.338708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.517875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.462167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.657875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.295416 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.264209 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.310625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.375458 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.410625 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.433958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.671583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.507333 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.221084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.337792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.26875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.336375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.380416 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.649583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.162292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.130458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.299875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.323417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.662916 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.271458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.30425 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.36875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.652958 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.29525 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.130833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.293792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.316 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.712625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.271708 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.37375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.717167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.456875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.034125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.358708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.292042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.308833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.665291 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.143833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.109375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.438583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.433583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.023583 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.347291 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.30925 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.264459 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.36475 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.646375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.289041 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.279083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.489292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.126 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.383916 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.3395 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.635042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.416916 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.681 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.300209 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.281333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.426375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.336417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.699041 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.1705 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.181292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.37425 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.031875 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 8.901292 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 503.705666 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 349.334666 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.120375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 12.254125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 402.702042 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 360.863042 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.202417 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 16.407959 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 405.714917 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 354.0695 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a0fc14ae069f6d190f6681f661d8ec1d8f7e04db9f5572413d103bf77c4c8ea9" + } + ], + "limitations": [ + "No core affinity or frequency tracing; not proof of the prior timing cause.", + "Finite C-contiguous workloads; compilation excluded from warm timings.", + "Interpreter has a smaller sample budget and participates in initial rounds only." + ] +} diff --git a/plans/menudet-jit-expanded-lowering.json b/plans/menudet-jit-expanded-lowering.json new file mode 100644 index 000000000..ad1ad3e7e --- /dev/null +++ b/plans/menudet-jit-expanded-lowering.json @@ -0,0 +1,647 @@ +{ + "platform": "macOS-26.6.2-arm64-arm-64bit-Mach-O", + "nitems": 65536, + "repeats": 7, + "technique": "Median across fresh processes of native best-of-warm timings; fixed backend order", + "limitations": [ + "Compilation excluded; not an interleaved compiler-ranking experiment.", + "Native harness compares result bytes with the interpreter." + ], + "executable_sha256": "37c60f071f022047a076c4ac71f25308b5c8d5c267f2a2e60967e0fb391d8a56", + "linked_native_sha256": { + "libminiexpr.dylib": "dc12528904b586520dd5f343f93267853063361b2cf799e415f6b39d1c4d6ad2" + }, + "compiler_versions": { + "gcc-16": "gcc-16 (Homebrew GCC 16.2.0) 16.2.0\nCopyright (C) 2026 Free Software Foundation, Inc.\nThis is free software; see the source for copying conditions. There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n", + "clang": "Apple clang version 21.0.0 (clang-2100.3.34.2)\nTarget: arm64-apple-darwin25.6.0\nThread model: posix\nInstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin\n" + }, + "summary": [ + { + "case": "A math-call: sin(x)+cos(x)", + "interpreter_ms": 77.063, + "interpreter_range_ms": [ + 76.786, + 77.443 + ], + "tcc_ms": 6.86, + "tcc_range_ms": [ + 6.757, + 7.087 + ], + "tcc_route": "JIT", + "gcc_ms": 6.829, + "gcc_range_ms": [ + 6.669, + 6.949 + ], + "gcc_route": "JIT", + "clang_ms": 6.776, + "clang_range_ms": [ + 6.683, + 6.996 + ], + "clang_route": "JIT" + }, + { + "case": "B integer-dtype: int32 x+y", + "interpreter_ms": 68.578, + "interpreter_range_ms": [ + 68.512, + 68.649 + ], + "tcc_ms": 0.23, + "tcc_range_ms": [ + 0.227, + 0.231 + ], + "tcc_route": "JIT", + "gcc_ms": 0.051, + "gcc_range_ms": [ + 0.046, + 0.086 + ], + "gcc_route": "JIT", + "clang_ms": 0.02, + "clang_range_ms": [ + 0.007, + 0.021 + ], + "clang_route": "JIT" + }, + { + "case": "C float-operator: x // 3.0", + "interpreter_ms": 68.513, + "interpreter_range_ms": [ + 68.217, + 68.589 + ], + "tcc_ms": 68.612, + "tcc_range_ms": [ + 68.434, + 68.615 + ], + "tcc_route": "fb", + "gcc_ms": 68.606, + "gcc_range_ms": [ + 68.278, + 68.695 + ], + "gcc_route": "fb", + "clang_ms": 68.646, + "clang_range_ms": [ + 68.438, + 68.816 + ], + "clang_route": "fb" + }, + { + "case": "D local-temp: y=x*2; y+1", + "interpreter_ms": 136.696, + "interpreter_range_ms": [ + 135.895, + 137.437 + ], + "tcc_ms": 0.101, + "tcc_range_ms": [ + 0.1, + 0.101 + ], + "tcc_route": "JIT", + "gcc_ms": 0.133, + "gcc_range_ms": [ + 0.052, + 0.23 + ], + "gcc_route": "JIT", + "clang_ms": 0.122, + "clang_range_ms": [ + 0.114, + 0.139 + ], + "clang_route": "JIT" + }, + { + "case": "E control-flow: if x>0 else -x", + "interpreter_ms": 82.466, + "interpreter_range_ms": [ + 82.369, + 82.753 + ], + "tcc_ms": 0.19, + "tcc_range_ms": [ + 0.175, + 0.193 + ], + "tcc_route": "JIT", + "gcc_ms": 0.118, + "gcc_range_ms": [ + 0.113, + 0.149 + ], + "gcc_route": "JIT", + "clang_ms": 0.102, + "clang_range_ms": [ + 0.102, + 0.134 + ], + "clang_route": "JIT" + }, + { + "case": "F reduction: sum(x)", + "interpreter_ms": 0.492, + "interpreter_range_ms": [ + 0.489, + 0.926 + ], + "tcc_ms": 0.473, + "tcc_range_ms": [ + 0.463, + 0.49 + ], + "tcc_route": "fb", + "gcc_ms": 0.471, + "gcc_range_ms": [ + 0.464, + 0.479 + ], + "gcc_route": "fb", + "clang_ms": 0.472, + "clang_range_ms": [ + 0.461, + 0.478 + ], + "clang_route": "fb" + }, + { + "case": "G nd-context: x + _i0", + "interpreter_ms": 68.797, + "interpreter_range_ms": [ + 68.688, + 69.351 + ], + "tcc_ms": 69.094, + "tcc_range_ms": [ + 68.951, + 69.16 + ], + "tcc_route": "fb", + "gcc_ms": 68.965, + "gcc_range_ms": [ + 68.747, + 69.332 + ], + "gcc_route": "fb", + "clang_ms": 69.028, + "clang_range_ms": [ + 68.822, + 69.587 + ], + "clang_route": "fb" + }, + { + "case": "control eligible: where(x!=0,y/x,y)", + "interpreter_ms": 192.634, + "interpreter_range_ms": [ + 192.334, + 193.118 + ], + "tcc_ms": 0.216, + "tcc_range_ms": [ + 0.211, + 0.222 + ], + "tcc_route": "JIT", + "gcc_ms": 0.195, + "gcc_range_ms": [ + 0.167, + 0.218 + ], + "gcc_route": "JIT", + "clang_ms": 0.144, + "clang_range_ms": [ + 0.134, + 0.176 + ], + "clang_route": "JIT" + } + ], + "processes": [ + [ + { + "case": "A math-call: sin(x)+cos(x)", + "interpreter_ms": 76.786, + "tcc_ms": 6.86, + "tcc_route": "JIT", + "gcc_ms": 6.949, + "gcc_route": "JIT", + "clang_ms": 6.996, + "clang_route": "JIT" + }, + { + "case": "B integer-dtype: int32 x+y", + "interpreter_ms": 68.551, + "tcc_ms": 0.227, + "tcc_route": "JIT", + "gcc_ms": 0.086, + "gcc_route": "JIT", + "clang_ms": 0.007, + "clang_route": "JIT" + }, + { + "case": "C float-operator: x // 3.0", + "interpreter_ms": 68.217, + "tcc_ms": 68.615, + "tcc_route": "fb", + "gcc_ms": 68.606, + "gcc_route": "fb", + "clang_ms": 68.438, + "clang_route": "fb" + }, + { + "case": "D local-temp: y=x*2; y+1", + "interpreter_ms": 136.525, + "tcc_ms": 0.1, + "tcc_route": "JIT", + "gcc_ms": 0.23, + "gcc_route": "JIT", + "clang_ms": 0.116, + "clang_route": "JIT" + }, + { + "case": "E control-flow: if x>0 else -x", + "interpreter_ms": 82.369, + "tcc_ms": 0.186, + "tcc_route": "JIT", + "gcc_ms": 0.148, + "gcc_route": "JIT", + "clang_ms": 0.134, + "clang_route": "JIT" + }, + { + "case": "F reduction: sum(x)", + "interpreter_ms": 0.489, + "tcc_ms": 0.463, + "tcc_route": "fb", + "gcc_ms": 0.464, + "gcc_route": "fb", + "clang_ms": 0.461, + "clang_route": "fb" + }, + { + "case": "G nd-context: x + _i0", + "interpreter_ms": 68.716, + "tcc_ms": 69.094, + "tcc_route": "fb", + "gcc_ms": 68.965, + "gcc_route": "fb", + "clang_ms": 69.028, + "clang_route": "fb" + }, + { + "case": "control eligible: where(x!=0,y/x,y)", + "interpreter_ms": 192.489, + "tcc_ms": 0.211, + "tcc_route": "JIT", + "gcc_ms": 0.18, + "gcc_route": "JIT", + "clang_ms": 0.134, + "clang_route": "JIT" + } + ], + [ + { + "case": "A math-call: sin(x)+cos(x)", + "interpreter_ms": 76.958, + "tcc_ms": 6.757, + "tcc_route": "JIT", + "gcc_ms": 6.794, + "gcc_route": "JIT", + "clang_ms": 6.683, + "clang_route": "JIT" + }, + { + "case": "B integer-dtype: int32 x+y", + "interpreter_ms": 68.63, + "tcc_ms": 0.23, + "tcc_route": "JIT", + "gcc_ms": 0.047, + "gcc_route": "JIT", + "clang_ms": 0.018, + "clang_route": "JIT" + }, + { + "case": "C float-operator: x // 3.0", + "interpreter_ms": 68.217, + "tcc_ms": 68.448, + "tcc_route": "fb", + "gcc_ms": 68.278, + "gcc_route": "fb", + "clang_ms": 68.646, + "clang_route": "fb" + }, + { + "case": "D local-temp: y=x*2; y+1", + "interpreter_ms": 135.895, + "tcc_ms": 0.101, + "tcc_route": "JIT", + "gcc_ms": 0.136, + "gcc_route": "JIT", + "clang_ms": 0.139, + "clang_route": "JIT" + }, + { + "case": "E control-flow: if x>0 else -x", + "interpreter_ms": 82.542, + "tcc_ms": 0.175, + "tcc_route": "JIT", + "gcc_ms": 0.113, + "gcc_route": "JIT", + "clang_ms": 0.102, + "clang_route": "JIT" + }, + { + "case": "F reduction: sum(x)", + "interpreter_ms": 0.492, + "tcc_ms": 0.472, + "tcc_route": "fb", + "gcc_ms": 0.466, + "gcc_route": "fb", + "clang_ms": 0.472, + "clang_route": "fb" + }, + { + "case": "G nd-context: x + _i0", + "interpreter_ms": 68.688, + "tcc_ms": 69.081, + "tcc_route": "fb", + "gcc_ms": 68.882, + "gcc_route": "fb", + "clang_ms": 68.822, + "clang_route": "fb" + }, + { + "case": "control eligible: where(x!=0,y/x,y)", + "interpreter_ms": 192.334, + "tcc_ms": 0.222, + "tcc_route": "JIT", + "gcc_ms": 0.195, + "gcc_route": "JIT", + "clang_ms": 0.138, + "clang_route": "JIT" + } + ], + [ + { + "case": "A math-call: sin(x)+cos(x)", + "interpreter_ms": 77.063, + "tcc_ms": 6.985, + "tcc_route": "JIT", + "gcc_ms": 6.922, + "gcc_route": "JIT", + "clang_ms": 6.756, + "clang_route": "JIT" + }, + { + "case": "B integer-dtype: int32 x+y", + "interpreter_ms": 68.649, + "tcc_ms": 0.231, + "tcc_route": "JIT", + "gcc_ms": 0.046, + "gcc_route": "JIT", + "clang_ms": 0.021, + "clang_route": "JIT" + }, + { + "case": "C float-operator: x // 3.0", + "interpreter_ms": 68.589, + "tcc_ms": 68.612, + "tcc_route": "fb", + "gcc_ms": 68.695, + "gcc_route": "fb", + "clang_ms": 68.773, + "clang_route": "fb" + }, + { + "case": "D local-temp: y=x*2; y+1", + "interpreter_ms": 136.696, + "tcc_ms": 0.101, + "tcc_route": "JIT", + "gcc_ms": 0.133, + "gcc_route": "JIT", + "clang_ms": 0.126, + "clang_route": "JIT" + }, + { + "case": "E control-flow: if x>0 else -x", + "interpreter_ms": 82.46, + "tcc_ms": 0.193, + "tcc_route": "JIT", + "gcc_ms": 0.114, + "gcc_route": "JIT", + "clang_ms": 0.102, + "clang_route": "JIT" + }, + { + "case": "F reduction: sum(x)", + "interpreter_ms": 0.49, + "tcc_ms": 0.489, + "tcc_route": "fb", + "gcc_ms": 0.479, + "gcc_route": "fb", + "clang_ms": 0.478, + "clang_route": "fb" + }, + { + "case": "G nd-context: x + _i0", + "interpreter_ms": 68.95, + "tcc_ms": 69.16, + "tcc_route": "fb", + "gcc_ms": 68.977, + "gcc_route": "fb", + "clang_ms": 69.145, + "clang_route": "fb" + }, + { + "case": "control eligible: where(x!=0,y/x,y)", + "interpreter_ms": 193.118, + "tcc_ms": 0.214, + "tcc_route": "JIT", + "gcc_ms": 0.203, + "gcc_route": "JIT", + "clang_ms": 0.144, + "clang_route": "JIT" + } + ], + [ + { + "case": "A math-call: sin(x)+cos(x)", + "interpreter_ms": 77.261, + "tcc_ms": 6.834, + "tcc_route": "JIT", + "gcc_ms": 6.829, + "gcc_route": "JIT", + "clang_ms": 6.776, + "clang_route": "JIT" + }, + { + "case": "B integer-dtype: int32 x+y", + "interpreter_ms": 68.512, + "tcc_ms": 0.23, + "tcc_route": "JIT", + "gcc_ms": 0.051, + "gcc_route": "JIT", + "clang_ms": 0.02, + "clang_route": "JIT" + }, + { + "case": "C float-operator: x // 3.0", + "interpreter_ms": 68.549, + "tcc_ms": 68.434, + "tcc_route": "fb", + "gcc_ms": 68.584, + "gcc_route": "fb", + "clang_ms": 68.505, + "clang_route": "fb" + }, + { + "case": "D local-temp: y=x*2; y+1", + "interpreter_ms": 137.437, + "tcc_ms": 0.1, + "tcc_route": "JIT", + "gcc_ms": 0.127, + "gcc_route": "JIT", + "clang_ms": 0.114, + "clang_route": "JIT" + }, + { + "case": "E control-flow: if x>0 else -x", + "interpreter_ms": 82.753, + "tcc_ms": 0.191, + "tcc_route": "JIT", + "gcc_ms": 0.149, + "gcc_route": "JIT", + "clang_ms": 0.109, + "clang_route": "JIT" + }, + { + "case": "F reduction: sum(x)", + "interpreter_ms": 0.926, + "tcc_ms": 0.473, + "tcc_route": "fb", + "gcc_ms": 0.473, + "gcc_route": "fb", + "clang_ms": 0.472, + "clang_route": "fb" + }, + { + "case": "G nd-context: x + _i0", + "interpreter_ms": 68.797, + "tcc_ms": 69.159, + "tcc_route": "fb", + "gcc_ms": 69.332, + "gcc_route": "fb", + "clang_ms": 69.587, + "clang_route": "fb" + }, + { + "case": "control eligible: where(x!=0,y/x,y)", + "interpreter_ms": 192.888, + "tcc_ms": 0.22, + "tcc_route": "JIT", + "gcc_ms": 0.167, + "gcc_route": "JIT", + "clang_ms": 0.176, + "clang_route": "JIT" + } + ], + [ + { + "case": "A math-call: sin(x)+cos(x)", + "interpreter_ms": 77.443, + "tcc_ms": 7.087, + "tcc_route": "JIT", + "gcc_ms": 6.669, + "gcc_route": "JIT", + "clang_ms": 6.804, + "clang_route": "JIT" + }, + { + "case": "B integer-dtype: int32 x+y", + "interpreter_ms": 68.578, + "tcc_ms": 0.23, + "tcc_route": "JIT", + "gcc_ms": 0.058, + "gcc_route": "JIT", + "clang_ms": 0.02, + "clang_route": "JIT" + }, + { + "case": "C float-operator: x // 3.0", + "interpreter_ms": 68.513, + "tcc_ms": 68.615, + "tcc_route": "fb", + "gcc_ms": 68.609, + "gcc_route": "fb", + "clang_ms": 68.816, + "clang_route": "fb" + }, + { + "case": "D local-temp: y=x*2; y+1", + "interpreter_ms": 137.192, + "tcc_ms": 0.101, + "tcc_route": "JIT", + "gcc_ms": 0.052, + "gcc_route": "JIT", + "clang_ms": 0.122, + "clang_route": "JIT" + }, + { + "case": "E control-flow: if x>0 else -x", + "interpreter_ms": 82.466, + "tcc_ms": 0.19, + "tcc_route": "JIT", + "gcc_ms": 0.118, + "gcc_route": "JIT", + "clang_ms": 0.102, + "clang_route": "JIT" + }, + { + "case": "F reduction: sum(x)", + "interpreter_ms": 0.751, + "tcc_ms": 0.49, + "tcc_route": "fb", + "gcc_ms": 0.471, + "gcc_route": "fb", + "clang_ms": 0.472, + "clang_route": "fb" + }, + { + "case": "G nd-context: x + _i0", + "interpreter_ms": 69.351, + "tcc_ms": 68.951, + "tcc_route": "fb", + "gcc_ms": 68.747, + "gcc_route": "fb", + "clang_ms": 68.858, + "clang_route": "fb" + }, + { + "case": "control eligible: where(x!=0,y/x,y)", + "interpreter_ms": 192.634, + "tcc_ms": 0.216, + "tcc_route": "JIT", + "gcc_ms": 0.218, + "gcc_route": "JIT", + "clang_ms": 0.165, + "clang_route": "JIT" + } + ] + ], + "raw_output": [ + "MiniExpr portable 1.1: interpreter vs JIT (warm per-evaluation time)\nnitems=65536 repeats=7 (cold load/compile excluded; best of warm runs; ms per full-array call)\n\ncase (family / example) interpreter tcc gcc-16 clang\nA math-call: sin(x)+cos(x) 76.786 I 6.860 JIT 6.949 JIT 6.996 JIT\nB integer-dtype: int32 x+y 68.551 I 0.227 JIT 0.086 JIT 0.007 JIT\nC float-operator: x // 3.0 68.217 I 68.615 fb 68.606 fb 68.438 fb\nD local-temp: y=x*2; y+1 136.525 I 0.100 JIT 0.230 JIT 0.116 JIT\nE control-flow: if x>0 else -x 82.369 I 0.186 JIT 0.148 JIT 0.134 JIT\nF reduction: sum(x) 0.489 I 0.463 fb 0.464 fb 0.461 fb\nG nd-context: x + _i0 68.716 I 69.094 fb 68.965 fb 69.028 fb\ncontrol eligible: where(x!=0,y/x,y) 192.489 I 0.211 JIT 0.180 JIT 0.134 JIT\n\nlegend: I=interpreter JIT=compiled kernel fb=JIT declined, interpreter fallback\n *=warm result differs bitwise from the interpreter reference\ncompiled control kernel per backend: tcc=yes gcc-16=yes clang=yes\nvalue checks: all match interpreter\n", + "MiniExpr portable 1.1: interpreter vs JIT (warm per-evaluation time)\nnitems=65536 repeats=7 (cold load/compile excluded; best of warm runs; ms per full-array call)\n\ncase (family / example) interpreter tcc gcc-16 clang\nA math-call: sin(x)+cos(x) 76.958 I 6.757 JIT 6.794 JIT 6.683 JIT\nB integer-dtype: int32 x+y 68.630 I 0.230 JIT 0.047 JIT 0.018 JIT\nC float-operator: x // 3.0 68.217 I 68.448 fb 68.278 fb 68.646 fb\nD local-temp: y=x*2; y+1 135.895 I 0.101 JIT 0.136 JIT 0.139 JIT\nE control-flow: if x>0 else -x 82.542 I 0.175 JIT 0.113 JIT 0.102 JIT\nF reduction: sum(x) 0.492 I 0.472 fb 0.466 fb 0.472 fb\nG nd-context: x + _i0 68.688 I 69.081 fb 68.882 fb 68.822 fb\ncontrol eligible: where(x!=0,y/x,y) 192.334 I 0.222 JIT 0.195 JIT 0.138 JIT\n\nlegend: I=interpreter JIT=compiled kernel fb=JIT declined, interpreter fallback\n *=warm result differs bitwise from the interpreter reference\ncompiled control kernel per backend: tcc=yes gcc-16=yes clang=yes\nvalue checks: all match interpreter\n", + "MiniExpr portable 1.1: interpreter vs JIT (warm per-evaluation time)\nnitems=65536 repeats=7 (cold load/compile excluded; best of warm runs; ms per full-array call)\n\ncase (family / example) interpreter tcc gcc-16 clang\nA math-call: sin(x)+cos(x) 77.063 I 6.985 JIT 6.922 JIT 6.756 JIT\nB integer-dtype: int32 x+y 68.649 I 0.231 JIT 0.046 JIT 0.021 JIT\nC float-operator: x // 3.0 68.589 I 68.612 fb 68.695 fb 68.773 fb\nD local-temp: y=x*2; y+1 136.696 I 0.101 JIT 0.133 JIT 0.126 JIT\nE control-flow: if x>0 else -x 82.460 I 0.193 JIT 0.114 JIT 0.102 JIT\nF reduction: sum(x) 0.490 I 0.489 fb 0.479 fb 0.478 fb\nG nd-context: x + _i0 68.950 I 69.160 fb 68.977 fb 69.145 fb\ncontrol eligible: where(x!=0,y/x,y) 193.118 I 0.214 JIT 0.203 JIT 0.144 JIT\n\nlegend: I=interpreter JIT=compiled kernel fb=JIT declined, interpreter fallback\n *=warm result differs bitwise from the interpreter reference\ncompiled control kernel per backend: tcc=yes gcc-16=yes clang=yes\nvalue checks: all match interpreter\n", + "MiniExpr portable 1.1: interpreter vs JIT (warm per-evaluation time)\nnitems=65536 repeats=7 (cold load/compile excluded; best of warm runs; ms per full-array call)\n\ncase (family / example) interpreter tcc gcc-16 clang\nA math-call: sin(x)+cos(x) 77.261 I 6.834 JIT 6.829 JIT 6.776 JIT\nB integer-dtype: int32 x+y 68.512 I 0.230 JIT 0.051 JIT 0.020 JIT\nC float-operator: x // 3.0 68.549 I 68.434 fb 68.584 fb 68.505 fb\nD local-temp: y=x*2; y+1 137.437 I 0.100 JIT 0.127 JIT 0.114 JIT\nE control-flow: if x>0 else -x 82.753 I 0.191 JIT 0.149 JIT 0.109 JIT\nF reduction: sum(x) 0.926 I 0.473 fb 0.473 fb 0.472 fb\nG nd-context: x + _i0 68.797 I 69.159 fb 69.332 fb 69.587 fb\ncontrol eligible: where(x!=0,y/x,y) 192.888 I 0.220 JIT 0.167 JIT 0.176 JIT\n\nlegend: I=interpreter JIT=compiled kernel fb=JIT declined, interpreter fallback\n *=warm result differs bitwise from the interpreter reference\ncompiled control kernel per backend: tcc=yes gcc-16=yes clang=yes\nvalue checks: all match interpreter\n", + "MiniExpr portable 1.1: interpreter vs JIT (warm per-evaluation time)\nnitems=65536 repeats=7 (cold load/compile excluded; best of warm runs; ms per full-array call)\n\ncase (family / example) interpreter tcc gcc-16 clang\nA math-call: sin(x)+cos(x) 77.443 I 7.087 JIT 6.669 JIT 6.804 JIT\nB integer-dtype: int32 x+y 68.578 I 0.230 JIT 0.058 JIT 0.020 JIT\nC float-operator: x // 3.0 68.513 I 68.615 fb 68.609 fb 68.816 fb\nD local-temp: y=x*2; y+1 137.192 I 0.101 JIT 0.052 JIT 0.122 JIT\nE control-flow: if x>0 else -x 82.466 I 0.190 JIT 0.118 JIT 0.102 JIT\nF reduction: sum(x) 0.751 I 0.490 fb 0.471 fb 0.472 fb\nG nd-context: x + _i0 69.351 I 68.951 fb 68.747 fb 68.858 fb\ncontrol eligible: where(x!=0,y/x,y) 192.634 I 0.216 JIT 0.218 JIT 0.165 JIT\n\nlegend: I=interpreter JIT=compiled kernel fb=JIT declined, interpreter fallback\n *=warm result differs bitwise from the interpreter reference\ncompiled control kernel per backend: tcc=yes gcc-16=yes clang=yes\nvalue checks: all match interpreter\n" + ] +} diff --git a/plans/menudet-jit-expanded-lowering.md b/plans/menudet-jit-expanded-lowering.md new file mode 100644 index 000000000..2614c8882 --- /dev/null +++ b/plans/menudet-jit-expanded-lowering.md @@ -0,0 +1,177 @@ +# Menudet expanded typed JIT lowering + +## Scope + +Portable 1.1 remains opt-in (`jit=True` / `ME_JIT_ON`). All backends receive the +same generated C source, now identified as `lowering-r8 mask-compare-math-abi-r4`. +Checked 1.0, dependency pins, default backend selection and artifact versions do +not change. + +New supported families: + +- Straight-line local assignments and reassignment. Typed volatile lane-local + stores preserve assignment precision and floating exceptions, including unused + assignments. This intentionally leaves optimization headroom. +- Simple `if`/`elif`/`else`, nested branch lowering and lane-local returns. Returns + advance the participating lane rather than ending the whole array kernel. + Definite assignment is rechecked conservatively across branch alternatives; + unsupported or uncertain cases stay interpreted. +- Same-dtype signed/unsigned 8/16/32/64-bit `+`, `-`, `*` and negation. All arithmetic + uses uint64 modular operations, then narrows unsigned and bit-copies into the + target representation; no signed C overflow or out-of-range signed cast is used. +- Unary float32/float64 `sin`, `cos`, `tan`, `exp`, `log`, `sqrt`, `floor`, `ceil`. + A private invocation-time bridge reuses the authoritative native `p_math` + implementation. It retains host libm selection/precision and diagnostics, but + still incurs a host call and function-name dispatch per participating node. + +Existing lazy `where`, Boolean short circuiting, ordinary inline floating +comparisons, exceptional NaN comparison bridge, participating masks, scoped fenv +and final floating conversions are retained. Native math bindings are borrowed +typed-tree pointers supplied at invocation, not serialized in artifacts/source. + +The shared arithmetic corpus caught `uint64` versus a weak signed `-1` comparison: +C's usual unsigned conversion would incorrectly equate it with UINT64_MAX. Mixed +signed/unsigned comparison nodes without explicit common promotion now fail closed +to the authoritative interpreter. Mixed-width integer conversions, integer +division/shifts, floating `//`, other math calls, loops, block-scalar reductions +and ND context remain outside this slice. WASM host-pointer lowering remains +disabled; cross-platform numerical qualification is not implied by these host tests. + +## Validation + +- Before the test-only bulk refactor, full Python suite: **12,878 passed, 78 skipped**; + the focused actual-JIT suite + separately passed **198** TCC/GCC/Clang tests. Optional corpus selectors were + not supplied to the full Python run; authoritative corpora run natively below. +- Expanded focused Python tests require actual TCC/GCC/Clang compilation, covering + integer overflow/min/max boundaries, finite value bits, quiet/signaling NaNs, + function diagnostics, lazy and masked participation, local assignment rounding, + unused assignment diagnostics, reassignment and branches. +- Standalone native JIT tests now cover locals, early returns, branch-assigned + locals, unary math and modular integer composition, with and without masks. +- Full native suite: 427 passed after excluding the signed/unsigned comparison + corner case, including authoritative arithmetic and function corpora. +- Explicit request-on TCC corpus execution matches all **3,193 arithmetic** and + **1,154 function** cases. Actual compiled coverage increases from the original + **181 to 1,249 arithmetic cases** and **15 to 135 function cases**. Remaining + routes retain their interpreter/expected-diagnostic classification. Counts: + `plans/menudet-jit-expanded-conformance.json`. +- Six ASan/UBSan checks passed, including forced actual GCC-JIT execution of the + expanded standalone fixtures. Sanitizer build emitted a duplicate-library linker + warning (`-lm`, `libminiexpr.a`); no new compiler warnings or sanitizer findings. +- Serial GCC compilation reached the former 300-second limit without a reported + value mismatch; a subsequent partially cached serial run passed in 289.69 seconds. + Serial Clang passed in 500.05 seconds. The test-only bulk refactor below restores + a **60-second timeout** rather than accepting these long compilation times. + +## Benchmark method + +The user's `../miniexpr/bench/benchmark_dsl_interpreter_vs_jit.c` is left unchanged. +`tools/menudet_lowering_bench.py` repeats it in five fresh processes with fresh JIT +cache directories. Each process uses 65,536 elements and seven warm repeats, with +the native harness's adaptive batching and minimum timing. Compilation is excluded +and result bytes are checked against the interpreter. + +This deliberately reproduces that harness, **not** the interleaved compiler-ranking +method. Use it for coverage and large interpreter speedups; fixed backend order, +minimum timing and untraced CPU placement/frequency do not support fine-grained +compiler rankings. The report records per-process rows, ranges, compiler versions, +executable/shared-library hashes and raw output. + +Reproduce with `MENUDET_WORK_DIR` set to the approved temporary directory: + +```sh +conda run -n blosc2 python -m tools.menudet_lowering_bench \ + "$BUILD/bench/benchmark_dsl_interpreter_vs_jit" \ + --report plans/menudet-jit-expanded-lowering.json +``` + +## Expanded coverage results + +Median of five native process results, warm milliseconds, 65,536 elements: + +| Family | Interpreter | TCC | GCC 16 | Clang 21 | Request-on route | +|---|---:|---:|---:|---:|---| +| A: `sin(x)+cos(x)` | 77.063 | 6.860 | 6.829 | 6.776 | JIT | +| B: int32 `x+y` | 68.578 | 0.230 | 0.051 | 0.020 | JIT | +| C: `x // 3.0` | 68.513 | 68.612 | 68.606 | 68.646 | interpreter | +| D: `y=x*2; return y+1` | 136.696 | 0.101 | 0.133 | 0.122 | JIT | +| E: `if x>0: return x; return -x` | 82.466 | 0.190 | 0.118 | 0.102 | JIT | +| F: `sum(x)` | 0.492 | 0.473 | 0.471 | 0.472 | interpreter | +| G: `x + _i0` | 68.797 | 69.094 | 68.965 | 69.028 | interpreter | +| Control: `where(x!=0,y/x,y)` | 192.634 | 0.216 | 0.195 | 0.144 | JIT | + +All five processes report bitwise agreement with the interpreter. Four formerly +unsupported families now compile on all three backends. Math is about **11×** +faster; the cheap integer/local/branch examples improve by hundreds to thousands +of times. The interpreter dispatch overhead dominates those large ratios, rather +than demonstrating broad superiority over NumPy/NumExpr. Math still pays host +bridge/name-dispatch overhead, and volatile local stores leave optimization room. + +Per-process compiler rankings fluctuate substantially under this harness (e.g. +GCC locals 0.052–0.230 ms); do not treat fine timing differences as compiler +rankings. Complete evidence: `plans/menudet-jit-expanded-lowering.json`. + +### Existing interleaved workloads + +The original shared-buffer/rotating-order benchmark was also rerun across five +fresh processes, without concurrent validation work. Warm milliseconds for +262,144 float64 elements; median of process medians, NumExpr single-threaded: + +| Workload | Interpreter | TCC | GCC 16 | Clang 21 | NumPy | NumExpr | +|---|---:|---:|---:|---:|---:|---:| +| Affine | 1068.613 | 0.674 | 0.314 | 0.274 | 0.344 | 0.400 | +| Polynomial | 803.097 | 0.683 | 0.169 | 0.145 | 0.341 | 0.333 | +| Lazy where | 940.055 | 1.064 | 0.383 | 0.341 | 0.596 | 0.480 | + +These remain consistent with the preceding inline-comparison rerun (GCC/Clang +where 0.385/0.344 ms). Values and actual compilation are checked before/after +sampling. Evidence: `plans/menudet-jit-expanded-interleaved.json`. + +## Exhaustive compiler tests without per-kernel process startup + +The cc corpus runner now preloads the same artifacts and invokes the same typed +portable source emitter. Each eligible function is copied unchanged into one C +translation unit, except for its unique exported symbol name. The shared helper +header must match byte-for-byte; compiler/FP configuration must agree. One normal +strict cc compilation produces the module. Every artifact retains its own typed +tree, runtime bindings and separately resolved compiled entry point. + +All numerical cases and assertions remain: inferred dtype, output bytes/tolerances, +floating status, raising/recovery, repeated calls and caller-fenv restoration. No +matrix sampling or replacing compiled execution with interpreter results is used. +The library is owned by the harness and stays loaded until all artifacts are freed. +Windows/WASM keep their existing runner route. `MENUDET_JIT_SERIAL=1` opts back +into the original per-artifact runtime compilation for comparison/debugging. + +Normal production compilation, cache identity and compiler options are unchanged. +Dedicated runtime/cache tests and the standalone JIT fixtures continue to exercise +per-kernel loading. Default CTest additionally includes full arithmetic/functions +cc corpus tests on hosts with an available compiler, with actual compilation +required. All exhaustive corpus timeouts are 60 seconds. + +Fresh-cache timings from `tools/menudet_batch_qualification.py`: + +| Corpus | Serial TCC | Bulk GCC 16 | Bulk Clang 21 | Cases / compiled kernels | +|---|---:|---:|---:|---:| +| Arithmetic | 26.11 s | 26.55 s | 25.99 s | 3,193 / 1,249 | +| Functions | 1.05 s | 1.63 s | 1.11 s | 1,154 / 135 | + +Arithmetic is **over 11× faster** than GCC's timed-out >300-second serial run +(10.9× versus its partially cached 289.69-second rerun), and **19.2× faster** than +Clang's 500.05-second serial run. Functions improve by **22.6× / 32.9×** versus +the 36.75 / 36.46-second serial GCC/Clang runs. Each cc corpus invokes the external +compiler **once**, but still executes every eligible compiled kernel. + +Every complete JSON result row is identical between serial TCC, bulk GCC and bulk +Clang, not just the aggregate pass count. Output SHA-256 digests and route counts +are recorded in `plans/menudet-jit-batch-qualification.json`. Remaining ~26-second +arithmetic cost is largely the unchanged exhaustive runner/evaluator work (serial +TCC takes the same time), not external compiler startup. + +Post-refactor validation: **429 native tests passed** in **44.25 seconds**, including +the two new exhaustive cc tests and existing per-kernel runtime/cache tests. A +rebuilt editable Python integration passed nine TCC/GCC/Clang runtime tests for +fallback/casts, lazy masks/status/concurrency and graph reuse. ASan/UBSan passed +the normal standalone actual-JIT fixture and the full 1,154-case bulk function +corpus; no sanitizer failures were reported. Ruff and diff checks pass. diff --git a/plans/menudet-jit-inline-comparisons-rerun.json b/plans/menudet-jit-inline-comparisons-rerun.json new file mode 100644 index 000000000..7f7dd955d --- /dev/null +++ b/plans/menudet-jit-inline-comparisons-rerun.json @@ -0,0 +1,16663 @@ +{ + "platform": "macOS-26.6.2-arm64-arm-64bit-Mach-O", + "numpy": "2.5.3", + "numexpr": "2.14.2", + "size": 262144, + "dtype": "float64", + "api": "flat", + "numexpr_threads": 1, + "technique": "Rotating workload/backend order; untimed warm-up; identical shared buffers", + "samples_per_process": { + "interpreter": 3, + "other_backends": 30 + }, + "compiler_versions": { + "gcc": "gcc-16 (Homebrew GCC 16.2.0) 16.2.0\nCopyright (C) 2026 Free Software Foundation, Inc.\nThis is free software; see the source for copying conditions. There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n", + "clang": "Apple clang version 21.0.0 (clang-2100.3.34.2)\nTarget: arm64-apple-darwin25.6.0\nThread model: posix\nInstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin\n" + }, + "summary": [ + { + "workload": "affine", + "backend": "interpreter", + "median_of_process_medians_ms": 1100.849791, + "process_medians_ms": [ + 1100.616, + 1095.689041, + 1100.849791, + 1109.452917, + 1103.621083 + ] + }, + { + "workload": "affine", + "backend": "tcc", + "median_of_process_medians_ms": 0.68275, + "process_medians_ms": [ + 0.6855834999999999, + 0.6973545000000001, + 0.68275, + 0.6821665, + 0.6769375 + ] + }, + { + "workload": "affine", + "backend": "gcc", + "median_of_process_medians_ms": 0.309979, + "process_medians_ms": [ + 0.31256249999999997, + 0.3164995, + 0.30491650000000003, + 0.308021, + 0.309979 + ] + }, + { + "workload": "affine", + "backend": "clang", + "median_of_process_medians_ms": 0.2722295, + "process_medians_ms": [ + 0.27595800000000004, + 0.2826875, + 0.2710005, + 0.2722295, + 0.2678125 + ] + }, + { + "workload": "affine", + "backend": "numpy", + "median_of_process_medians_ms": 0.356354, + "process_medians_ms": [ + 0.356354, + 0.3646255, + 0.33887500000000004, + 0.35587500000000005, + 0.365271 + ] + }, + { + "workload": "affine", + "backend": "numexpr", + "median_of_process_medians_ms": 0.40189549999999996, + "process_medians_ms": [ + 0.40189549999999996, + 0.4044375, + 0.39656250000000004, + 0.3946045, + 0.4155625 + ] + }, + { + "workload": "polynomial", + "backend": "interpreter", + "median_of_process_medians_ms": 825.95675, + "process_medians_ms": [ + 823.107625, + 825.95675, + 822.879709, + 829.539666, + 826.094625 + ] + }, + { + "workload": "polynomial", + "backend": "tcc", + "median_of_process_medians_ms": 0.687875, + "process_medians_ms": [ + 0.6901045, + 0.687875, + 0.678875, + 0.6906874999999999, + 0.640625 + ] + }, + { + "workload": "polynomial", + "backend": "gcc", + "median_of_process_medians_ms": 0.1713955, + "process_medians_ms": [ + 0.178083, + 0.1713955, + 0.1680835, + 0.1735, + 0.1606455 + ] + }, + { + "workload": "polynomial", + "backend": "clang", + "median_of_process_medians_ms": 0.1403125, + "process_medians_ms": [ + 0.1376665, + 0.1403125, + 0.1411875, + 0.140333, + 0.1375205 + ] + }, + { + "workload": "polynomial", + "backend": "numpy", + "median_of_process_medians_ms": 0.3431875, + "process_medians_ms": [ + 0.349375, + 0.3589995, + 0.3376255, + 0.329625, + 0.3431875 + ] + }, + { + "workload": "polynomial", + "backend": "numexpr", + "median_of_process_medians_ms": 0.340229, + "process_medians_ms": [ + 0.340229, + 0.339625, + 0.34170900000000004, + 0.342292, + 0.3224585 + ] + }, + { + "workload": "where", + "backend": "interpreter", + "median_of_process_medians_ms": 967.478708, + "process_medians_ms": [ + 967.478708, + 964.718542, + 966.92975, + 971.489084, + 968.612875 + ] + }, + { + "workload": "where", + "backend": "tcc", + "median_of_process_medians_ms": 1.074521, + "process_medians_ms": [ + 1.063854, + 1.074521, + 1.075896, + 1.0825624999999999, + 1.053667 + ] + }, + { + "workload": "where", + "backend": "gcc", + "median_of_process_medians_ms": 0.384771, + "process_medians_ms": [ + 0.3852085, + 0.384771, + 0.377438, + 0.3908335, + 0.3822085 + ] + }, + { + "workload": "where", + "backend": "clang", + "median_of_process_medians_ms": 0.34427050000000003, + "process_medians_ms": [ + 0.3369795, + 0.345375, + 0.34625, + 0.34427050000000003, + 0.326875 + ] + }, + { + "workload": "where", + "backend": "numpy", + "median_of_process_medians_ms": 0.6205, + "process_medians_ms": [ + 0.6205, + 0.6114165, + 0.6285000000000001, + 0.614959, + 0.6351665 + ] + }, + { + "workload": "where", + "backend": "numexpr", + "median_of_process_medians_ms": 0.4847705, + "process_medians_ms": [ + 0.4852915, + 0.4886875, + 0.47954149999999995, + 0.4847705, + 0.4810835 + ] + } + ], + "processes": [ + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1100.616 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.760791 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.311958 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.273 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.365 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.407958 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 823.523292 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.792667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.18475 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.1735 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.454667 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.369417 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 967.153416 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.148167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.401875 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.354709 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.681459 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.513209 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.686125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.199958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.159417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.347958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.346625 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 822.320584 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.162125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.412875 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.364416 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.711291 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.519709 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 967.478708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.789708 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.339667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.284542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.428583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.452875 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1100.846042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.474125 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.356125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.607875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.535208 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 969.070083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.158791 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.403917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.285333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.440125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.439875 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1098.621125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.786 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.195 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.149375 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.350792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.36825 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 823.107625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.969 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.4315 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.51025 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.670625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.302084 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.266083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.368458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.349459 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.669417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.180333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.164542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.625209 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.490125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.053583 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.355958 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.323417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.324375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.696708 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.170875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.1435 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.341583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.488583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.060583 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.451125 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.356917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.691625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.418167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.712042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.321416 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.286208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.368 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.039292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.359334 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.31475 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.539459 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.477333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.67325 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.304 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.257375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.354625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.379333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.719042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.2485 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.206625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.433666 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.337375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.314125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.276958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.340417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.386 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.674083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.175 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.134458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.328375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.325375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.664667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.4215 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.336667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.707833 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.475791 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.039666 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.146958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.329209 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.336833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.684333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.16775 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.328584 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.645 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.477042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.079916 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.421583 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.3075 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.361792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.414417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.689917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.302791 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.556458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.488125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.124459 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.410208 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.322125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.357667 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.393125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.646458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.280375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.251375 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.256875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.359083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.745375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.164958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.138708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.438916 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.693292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.320084 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.28475 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.417459 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.353583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.713708 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.168166 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.1335 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.345709 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.479834 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.035167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.383708 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.347458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.618833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.68575 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.384625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.129041 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.313917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.343583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.131917 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.441083 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.349208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.540709 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.482625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.679125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.311375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.361959 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.372 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.431958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.359917 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.32125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.504667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.456333 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.00775 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.291042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.254167 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.286875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.383875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.6425 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.163416 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.121917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.366375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.316625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.652916 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.268834 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.286708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.367042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.636542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.291041 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.2665 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.408458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.338166 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.684292 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.210709 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.325083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.622416 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.497042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.101375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.379666 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.389375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.353916 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.713542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.217542 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.154333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.631333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.46775 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.057916 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.346166 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.30325 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.265667 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.35575 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.629625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.299916 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.25775 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.530792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.121167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.395 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.355041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.682 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.424541 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.701625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.322834 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.283166 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.378959 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.355208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.688208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.180375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.16075 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.367375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.688958 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.343333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.285542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.338792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.447625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.690167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.185583 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.198833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.382084 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.352375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.089666 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.438583 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.339541 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.5555 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.480375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.172459 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.130167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.286375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.334125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.669 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.365375 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.321875 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.539166 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.474417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.045958 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.303208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.269792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.306583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.386375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.72975 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.426834 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.741375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.52825 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.11875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.384542 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.278208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.3795 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.423792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.692666 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.316791 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.157959 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.37875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.342292 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.71125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.18375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.3725 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.419417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.724959 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.355542 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.31725 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.4365 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.359167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.651625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.165333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.136625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.691958 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.525875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.0965 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.419541 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.358958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.335208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.694583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.177333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.1335 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.344083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.458416 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.042291 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.359292 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.333167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.566875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.383209 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.667542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.322792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.293041 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.357208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.07725 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.385625 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.327583 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.561375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.4725 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.667792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.505208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.289667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.382542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.452334 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.718791 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.162625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.129208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.389042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.419959 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.330375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.276083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.312667 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.377791 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.652375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.157458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.123084 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.284209 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.315459 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.6355 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.351209 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.321584 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.524667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.455292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.015625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.129709 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.287583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.318167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.693083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.256 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.371709 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.766792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.501625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.075417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.3925 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.275833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.348458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.400292 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.660583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.297666 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.571834 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.49675 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.055875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.384792 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.333875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.3245 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.388125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.68375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.30225 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.286833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.343917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.356833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.681167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.159958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.12225 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.401458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.687417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.323875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.241209 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.28075 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.3205 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.679333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.145917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.123708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.2725 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.449417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.040959 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.351125 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.33925 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.636917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.690042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.168917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.142 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.388459 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.334916 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.041542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.371125 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.337292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.60725 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.494 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.688083 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.290333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.266792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.346 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.402333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.356125 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.319375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.533834 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.487958 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.096792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.311833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.267791 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.344625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.401417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.682708 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.164125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.125292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.294792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.307917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.626333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.250792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.299708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.368333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.648958 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.303625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.124584 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.301291 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.322917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.694458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.1815 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.362167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.622167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.470042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.067125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.3765 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.386292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.356666 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.691291 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.218708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.135417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.653542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.465916 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.035042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.417583 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.373 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.422833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.416667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.698208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.324042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.275416 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.502583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.053167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.385875 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.334041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.618375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.390958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.705792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.313167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.272542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.3555 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.330583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.7025 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.178833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.149375 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.368834 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.046084 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 13.370125 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 772.44725 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 451.077083 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.151125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 6.276833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 410.061375 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 360.741291 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.089083 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 5.433791 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 413.643583 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 351.445875 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a036d40d1782f61be92eb2555bc217ec2d6396aa54472c374eec65c4e1d05ad2" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1095.689041 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.910875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.367625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.371375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.406417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.536625 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 823.627834 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.776709 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.184041 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.148917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.430083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.381584 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 964.718542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.175375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.412292 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.366291 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.780708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.51875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.701583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.181125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.157 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.379083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.345417 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 825.95675 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.169292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.411083 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.352625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.680083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.514916 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 965.494292 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.763834 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.310625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.268292 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.391167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.414125 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1095.566959 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.467042 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.397958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.640041 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.495583 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 963.408042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.134792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.329208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.280709 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.395041 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.422292 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1096.917209 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.750083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.181625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.152792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.361208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.364291 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 826.148208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.798959 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.404416 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.444417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.68925 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.31425 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.296333 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.36125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.349583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.651417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.172375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.151375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.574208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.486458 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.054375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.368542 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.340084 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.317833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.677542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.151708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.126541 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.361709 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.445833 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.013166 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.387292 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.357 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.665458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.42725 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.7025 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.3085 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.283083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.348667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.093334 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.399792 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.343041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.567583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.492833 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.683667 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.303333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.26525 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.368125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.419959 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.683125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.17025 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.140458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.337542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.324292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.317083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.264083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.362917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.387542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.696625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.222166 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.149083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.382292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.336792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.681708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.367583 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.34775 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.558125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.504792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.09 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.161292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.408917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.370333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.694167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.167375 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.330417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.616041 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.510209 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.063917 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.41625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.35975 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.342334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.477291 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.74025 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.327 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.616083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.5125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.069333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.387667 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.359916 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.382667 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.401875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.6825 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.350042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.281958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.3745 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.325584 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.641083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.180333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.129792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.370958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.678625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.313417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.298875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.354541 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.343375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.680125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.170416 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.137459 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.376667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.47975 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.044292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.38225 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.337375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.683833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.695417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.156833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.134917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.342375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.319041 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.016667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.364834 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.344708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.606792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.487041 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.686125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.318833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.475334 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.433125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.396083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.372416 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.353916 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.693125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.536625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.081917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.320459 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.296792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.39375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.412375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.694667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.177584 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.146625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.343042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.34025 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.69775 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.282292 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.354084 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.397125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.672167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.319041 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.158708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.359541 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.348417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.715083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.176583 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.332958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.5795 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.463584 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.106042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.463208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.447667 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.332583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.685458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.196583 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.159542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.658167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.522584 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.113708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.381 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.350042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.366334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.414208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.6595 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.286833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.247667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.445417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.027 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.37075 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.31575 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.517291 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.459459 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.714083 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.3005 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.281083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.415125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.312958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.668875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.149792 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.114959 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.300208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.661417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.308875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.283416 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.323416 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.40575 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.701958 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.165666 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.126958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.311708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.31875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.046542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.390083 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.376958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.574208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.476375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.153916 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.127708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.31825 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.314 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.687083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.381542 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.335708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.60225 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.508875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.052417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.28525 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.270208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.361458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.387 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.659292 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.345209 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.594167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.459625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.024166 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.364792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.27525 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.430042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.399292 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.679542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.3085 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.149334 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.352458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.339 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.688667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.165875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.3425 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.390375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.706875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.328042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.293666 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.364583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.329666 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.683875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.169292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.139083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.590542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.462291 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.085459 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.403291 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.351125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.35275 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.693625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.174917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.15425 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.368416 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.471959 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.095417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.381084 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.3485 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.543125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.401209 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.656708 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.29325 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.2455 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.328417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.081083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.392709 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.349917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.573083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.518167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.707792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.338125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.294166 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.436416 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.444625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.729125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.184542 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.140542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.376625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.32725 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.298416 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.265542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.340583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.425333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.743667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.160209 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.134209 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.331333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.318875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.663875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.364542 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.327417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.664667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.490417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.096125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.140167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.358458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.351167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.715208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.22925 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.326667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.653625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.509208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.04025 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.356 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.265583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.38975 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.391792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.702125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.327167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.660959 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.490334 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.052667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.387542 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.341166 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.433 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.422125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.7015 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.323833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.290917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.339917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.34175 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.6845 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.156209 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.128125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.40125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.7025 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.315916 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.286542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.350792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.342833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.698875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.176333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.12025 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.282791 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.470208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.070375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.387292 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.37 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.676417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.718208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.168042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.123625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.336208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.347292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.043625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.365459 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.351208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.568083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.479667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.649583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.286375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.250458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.311292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.373042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.362459 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.327709 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.501417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.447166 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.101166 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.357208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.323792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.396916 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.41575 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.702333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.172583 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.1315 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.301167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.344458 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.676875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.289833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.31425 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.403125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.698833 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.364083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.16275 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.337542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.324541 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.668583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.155667 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.328458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.526583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.467541 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.126166 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.448042 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.434792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.387625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.717459 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.183792 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.161167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.825666 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.508875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.041166 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.380333 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.335042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.320625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.384291 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.671292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.292334 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.310625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.454375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.078667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.43375 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.345541 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.637291 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.403083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.698084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.317292 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.262292 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.292375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.337125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.630875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.147834 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.108958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.253958 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.037834 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 3.25125 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 423.970333 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 359.944333 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.060542 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 5.137291 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 400.669083 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 348.398792 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.159166 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 5.643584 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 409.138709 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 351.378125 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a036d40d1782f61be92eb2555bc217ec2d6396aa54472c374eec65c4e1d05ad2" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1092.112375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.772167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.345917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.28175 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.417625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.432333 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 822.879709 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.737875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.167042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.135125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.372584 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.339458 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 966.92975 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.169167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.4265 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.369791 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.673708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.55575 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.7005 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.174041 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.154292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.393042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.365083 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 818.571875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.181625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.460083 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.361166 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.716333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.540458 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 966.418125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.750166 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.375875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.268 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.366167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.422083 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1100.849791 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.475833 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.346375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.616625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.508166 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 968.926625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.173708 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.3195 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.293916 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.397708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.436916 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1164.69225 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.722916 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.17575 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.153209 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.336167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.358875 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 828.092625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.742584 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.378833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.407083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.713291 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.39925 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.307625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.387542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.370708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.820917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.22425 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.138458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.638 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.481584 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.074834 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.370375 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.329625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.319084 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.628167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.160125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.129208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.315125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.486083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.044375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.360291 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.341 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.864833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.461334 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.728167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.3045 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.265917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.310084 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.043625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.363375 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.325708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.52875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.512709 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.696042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.283708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.275084 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.373917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.386583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.649875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.170459 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.123625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.295917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.315209 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.324709 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.250209 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.287833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.3755 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.6485 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.16375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.133458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.319458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.332583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.663834 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.364875 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.364125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.564666 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.463834 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.077709 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.262 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.373458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.339459 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.681167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.151458 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.327416 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.537458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.45025 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.038583 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.363167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.252875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.322334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.418625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.651084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.2865 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.672166 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.473083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.045833 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.3715 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.3685 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.437292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.426708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.703584 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.318041 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.277167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.339084 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.343625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.683917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.17075 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.142084 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.398 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.660292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.302291 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.2735 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.356834 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.346667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.679125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.176708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.141917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.449542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.529 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.154292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.397208 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.3905 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.705583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.68225 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.168042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.140458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.317958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.382916 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.085708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.371334 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.355625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.69325 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.469792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.6565 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.280709 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.25575 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.294833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.363958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.370042 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.337625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.529041 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.461666 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.152584 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.37625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.2805 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.387458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.400083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.69125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.169875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.1845 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.380958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.361625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.704417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.275625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.308833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.385541 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.679458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.296959 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.131084 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.325083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.503375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.653167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.162 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.330417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.590584 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.52975 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.117792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.429709 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.374875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.355375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.675 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.173209 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.13375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.581166 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.484292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.059667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.374792 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.348458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.316208 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.395125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.6815 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.3095 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.26825 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.468 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.104959 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.440041 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.346583 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.688958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.426459 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.706333 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.302583 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.272667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.389667 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.368125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.722875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.236958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.13875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.35925 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.655542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.2925 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.260291 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.304792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.390667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.639542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.157583 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.122 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.28675 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.308875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.084459 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.425625 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.338625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.619 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.488833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.175458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.132542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.280209 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.314333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.672083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.366209 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.359958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.564958 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.504042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.076709 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.304459 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.269334 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.310292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.379458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.685625 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.349541 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.733167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.480917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.100667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.435667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.269208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.379708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.390083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.6635 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.283125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.128125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.288 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.316541 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.646666 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.151083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.291208 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.381125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.656166 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.284083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.255667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.326666 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.316084 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.659917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.154792 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.17125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.558834 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.472 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.092625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.444667 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.333625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.347125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.678292 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.157708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.151208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.379875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.478166 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.043875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.391375 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.346125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.861917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.420542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.698875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.305917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.273958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.334334 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.058 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.371792 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.33475 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.901042 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.5015 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.684833 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.308209 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.274375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.348 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.384959 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.662875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.176083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.158208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.331084 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.331875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.299916 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.265625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.327291 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.382709 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.683 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.168125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.135958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.32675 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.341459 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.678625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.380084 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.337792 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.693416 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.467916 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.073875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.204166 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.376667 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.386208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.746458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.167917 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.34825 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.612375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.476708 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.047875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.3545 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.258375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.282959 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.394541 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.663792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.303083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.529209 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.467625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.038333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.36925 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.332583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.400583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.472375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.744917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.400583 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.38125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.416125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.332875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.689375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.163292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.152208 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.549542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.678334 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.32325 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.268041 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.3355 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.333167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.666542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.156541 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.149292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.334167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.457208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.042792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.356541 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.378833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.692833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.707625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.167667 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.137333 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.3095 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.363541 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.0485 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.4065 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.327708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.570583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.473041 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.650083 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.298959 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.273833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.34225 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.383291 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.393375 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.407917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.699667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.481334 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.09275 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.334041 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.292041 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.364084 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.408917 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.6825 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.183333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.15425 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.34875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.337334 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.700666 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.293708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.450458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.4585 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.720333 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.310625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.15075 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.396958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.341959 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.684917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.182667 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.360833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.644208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.491208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.087542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.392083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.362916 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.346958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.674791 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.178959 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.1435 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.541208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.464583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.075083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.445333 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.345291 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.288084 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.363458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.671417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.294042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.253458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.44325 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.017042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.352292 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.307 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.461458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.3595 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.649875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.305333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.261667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.300792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.312875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.643917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.146875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.116708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.268125 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.032875 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 3.0075 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 408.721375 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 365.822 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.067542 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 6.247166 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 424.672959 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 349.313334 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.042708 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 1.666334 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 406.489375 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 343.037125 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a036d40d1782f61be92eb2555bc217ec2d6396aa54472c374eec65c4e1d05ad2" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1109.452917 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.788875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.389583 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.288625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.385875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.41875 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 828.963583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.791709 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.187791 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.144167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.382291 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.374958 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 979.960917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.159416 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.397542 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.348041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.629 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.499041 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.74275 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.331792 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.1575 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.320792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.36325 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 829.539666 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.156834 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.374584 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.352542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.685417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.518625 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 971.489084 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.721541 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.298333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.26625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.371916 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.3955 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1109.401458 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.490916 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.367292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.679083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.53475 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 969.884459 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.182917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.307042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.269667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.353542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.413416 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1109.586917 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.758916 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.1765 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.142666 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.413292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.364875 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 830.64425 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.758458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.382042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.4075 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.679 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.306833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.266708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.355333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.330834 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.689375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.180667 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.139292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.560334 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.465208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.056958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.422041 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.424625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.354125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.696792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.175125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.138625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.436333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.517292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.089083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.387208 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.340791 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.601167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.386 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.674417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.288333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.256666 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.301292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.053208 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.35675 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.3305 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.565708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.542125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.747542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.325333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.332833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.359 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.394792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.697167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.18475 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.133709 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.30625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.333625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.296833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.261625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.302791 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.372083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.659209 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.173 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.144166 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.324 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.332417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.651958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.364917 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.333625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.537542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.461833 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.14575 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.263 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.3885 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.3835 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.732042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.171084 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.341375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.650125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.484791 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.058583 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.379 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.2805 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.329417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.410208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.684625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.360459 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.762291 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.515458 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.131958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.458125 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.405833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.391167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.42 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.681708 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.294167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.301958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.314292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.330666 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.681209 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.162625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.129125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.375083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.66425 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.292084 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.25875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.293584 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.332584 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.675958 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.16175 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.139542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.302083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.474167 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.093625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.430208 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.338584 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.621084 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.840833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.240583 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.146583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.382 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.3845 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.07625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.435791 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.408625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.590959 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.490041 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.67575 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.286792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.259791 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.293458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.372709 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.3555 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.324084 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.814667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.565417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.102042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.330167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.283583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.36425 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.393375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.709833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.23725 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.144083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.313708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.355875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.699625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.279917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.335291 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.410625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.682625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.309791 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.139125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.326625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.349875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.710625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.174 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.353083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.579958 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.495625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.079417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.438041 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.386166 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.339709 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.67675 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.166291 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.129417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.538958 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.461666 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.085708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.377 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.344166 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.297917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.38025 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.660333 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.291833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.254541 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.440209 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.05575 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.383916 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.332916 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.680041 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.471958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.694042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.296833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.285625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.429333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.351709 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.761209 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.235708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.1415 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.367709 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.674292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.29525 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.270917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.358125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.392875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.692 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.153792 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.132833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.307542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.32575 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.05525 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.367792 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.329458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.786083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.488 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.185834 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.132291 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.31675 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.330125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.656708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.384625 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.343042 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.704333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.476042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.098541 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.318417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.287042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.353625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.394417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.713208 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.343917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.569708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.47225 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.072292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.438333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.280834 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.396042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.407209 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.72 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.366459 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.163708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.464292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.399667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.681834 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.176583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.389 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.379041 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.657125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.299458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.271709 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.324583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.325167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.677625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.166167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.13975 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.59825 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.452334 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.136541 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.420125 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.344375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.344875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.68625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.163042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.1455 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.37025 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.476459 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.038583 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.385333 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.33525 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.60275 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.395958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.678916 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.313584 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.284083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.341875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.096542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.45375 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.404291 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.831791 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.522625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.83175 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.32225 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.269416 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.367375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.394167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.696583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.171666 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.140916 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.317333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.320708 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.289375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.2595 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.302416 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.3755 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.654583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.158708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.1325 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.346791 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.33525 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.680042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.404542 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.415625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.653708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.546459 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.095625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.138708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.395292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.350459 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.702625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.188042 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.344084 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.574458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.472583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.041375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.401166 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.296667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.428375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.42675 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.69175 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.310958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.843083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.513708 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.086167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.381458 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.354583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.347875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.396834 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.693458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.302458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.27275 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.300708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.314708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.644291 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.156875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.119958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.389083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.657 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.293291 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.267 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.296917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.307709 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.652834 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.146709 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.195042 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.421875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.472916 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.047083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.357458 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.352458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.608458 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.686125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.171125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.130791 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.325083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.33175 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.046459 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.359416 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.329583 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.529333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.451042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.677834 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.341458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.301958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.379417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.424375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.449417 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.329834 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.607167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.490166 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.067959 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.334708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.258833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.347167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.391708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.689167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.165416 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.138792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.321333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.329958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.683917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.274334 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.32675 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.380875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.672209 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.345166 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.186959 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.392958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.366833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.737459 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.18025 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.35675 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.67725 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.48475 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.067042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.394459 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.332625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.353 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.673625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.180875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.148292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.608834 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.473917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.07775 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.405208 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.412834 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.396792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.397125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.726833 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.375833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.271166 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.4835 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.086958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.37675 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.346375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.725125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.391708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.659917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.309 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.289958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.358459 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.34775 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.712625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.168625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.147666 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.299583 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.036416 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 3.0985 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 776.591625 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 538.352416 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.02975 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 1.559792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 430.906416 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 355.616125 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.042959 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 1.673667 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 388.576333 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 349.00275 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a036d40d1782f61be92eb2555bc217ec2d6396aa54472c374eec65c4e1d05ad2" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1108.005 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.74175 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.325166 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.310834 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.461125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.419542 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 826.094625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.720333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.16225 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.143167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.35475 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.418167 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1046.386125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.353291 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.490917 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.383166 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.645416 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.493208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.652375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.158083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.146208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.329959 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.327083 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 827.262542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.102709 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.383417 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.3065 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.630833 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.493292 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 965.907458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.725125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.298041 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.242958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.466667 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.503083 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1103.621083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.472791 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.325125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.626917 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.488167 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 968.612875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.101084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.307667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.26825 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.429334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.4195 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1101.497875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.752292 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.213042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.133583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.364375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.368 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 825.84125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.701917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.32175 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.420375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.656417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.295125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.265084 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.496417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.360959 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.6805 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.1885 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.16575 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.697 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.503125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.022042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.384083 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.329042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.346583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.6395 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.174416 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.14625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.3525 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.474583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.053584 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.417833 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.3425 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.630375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.412708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.727125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.316417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.274959 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.409292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.148208 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.395875 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.328958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.6825 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.4835 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.65525 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.310708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.30325 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.378458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.433791 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.673666 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.160375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.145791 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.339625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.315417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.294333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.259 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.320541 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.404208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.771291 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.1565 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.137041 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.3635 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.316 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.631209 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.369541 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.315791 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.580417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.477583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.092208 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.166667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.41275 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.34025 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.649125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.167875 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.328542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.815875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.515375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.064791 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.455708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.279583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.400542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.421083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.681042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.382458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.704208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.492083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.149166 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.397584 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.343917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.346459 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.457042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.707208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.323542 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.261208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.321208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.330083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.683875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.160916 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.134834 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.408333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.685667 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.305584 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.250416 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.362167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.304292 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.620667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.152917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.127583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.296542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.464041 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.065208 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.381 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.318292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.599375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.637416 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.165917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.133916 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.339417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.325667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.052834 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.414833 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.348125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.665084 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.509958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.733167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.333542 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.300917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.47825 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.444291 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.428625 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.349667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.68925 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.489708 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.011792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.29425 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.298166 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.352458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.419959 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.681333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.167917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.157959 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.339167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.328541 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.662458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.333958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.344917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.403791 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.660042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.308584 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.132375 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.329458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.313709 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.627916 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.155084 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.321458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.55575 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.473708 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.05025 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.363542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.302958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.300708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.616875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.149583 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.133625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.763375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.504167 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.023708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.370834 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.311958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.351459 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.376083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.678292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.28625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.24825 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.44075 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.986667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.354 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.298041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.530875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.382334 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.636291 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.299167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.253541 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.306208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.321584 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.690125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.248125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.146375 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.406791 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.689833 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.321167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.348916 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.404875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.414334 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.659625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.181584 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.144208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.317333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.315417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.009375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.378584 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.314667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.5535 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.457792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.155417 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.137708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.298375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.304625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.592459 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.365083 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.390833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.783375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.534 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.103625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.301667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.267375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.3925 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.391458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.666708 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.354167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.610917 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.473958 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.0195 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.406917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.261125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.388833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.423375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.675583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.3235 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.159042 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.3565 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.312417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.625292 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.157125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.312583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.378 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.672208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.300209 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.256292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.324916 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.308208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.630459 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.15075 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.128041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.584375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.478667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.027709 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.369541 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.313084 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.319167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.627625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.149584 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.125334 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.36525 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.515667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.05375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.366375 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.325208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.658917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.416791 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.770917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.296959 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.264333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.343667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.016834 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.366125 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.302375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.516208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.457208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.636459 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.288625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.254875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.289834 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.385041 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.662709 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.229542 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.183458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.438584 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.361 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.344459 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.276708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.338166 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.402583 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.699584 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.166875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.132167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.321666 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.309083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.59175 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.371916 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.323416 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.64525 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.475625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.054708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.137333 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.358625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.315042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.632458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.160167 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.329917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.739375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.504208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.067125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.435708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.296 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.396667 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.418833 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.703042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.327083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.561209 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.448583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.982375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.363416 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.298792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.370583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.384917 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.669417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.318416 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.27175 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.342125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.323333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.639792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.1535 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.136917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.385167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.630042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.309875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.251916 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.360875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.328291 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.641458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.169292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.157792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.351833 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.49575 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.0895 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.403125 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.36125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.712042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.651666 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.155125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.127166 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.34425 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.377875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.080333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.376833 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.313167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.6395 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.461625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.634167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.274208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.240375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.285125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.375625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.358833 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.334292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.505875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.449875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.002291 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.350042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.381292 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.436625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.423041 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.644542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.150166 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.125208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.28425 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.3005 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.622875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.252375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.299833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.377417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.643375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.310083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.123334 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.281333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.308375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.616834 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.159875 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.335958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.585875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.463083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.015833 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.396042 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.457833 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.393042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.694209 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.197834 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.15925 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.66375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.495958 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.109709 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.413042 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.352291 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.368375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.422125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.673083 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.335125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.26825 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.4745 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.001125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.356792 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.312709 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.53725 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.429875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.673708 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.330042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.296584 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.381375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.325208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.679375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.179708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.150917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.382042 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.036542 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 4.048709 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 412.073708 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 381.882709 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.0835 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 6.838625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 401.708584 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 354.151 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.224666 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 9.730292 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 411.513083 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 375.134542 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a036d40d1782f61be92eb2555bc217ec2d6396aa54472c374eec65c4e1d05ad2" + } + ], + "limitations": [ + "No core affinity or frequency tracing; not proof of the prior timing cause.", + "Finite C-contiguous workloads; compilation excluded from warm timings.", + "Interpreter has a smaller sample budget and participates in initial rounds only." + ] +} diff --git a/plans/menudet-jit-inline-comparisons.json b/plans/menudet-jit-inline-comparisons.json new file mode 100644 index 000000000..8e8b5ee4c --- /dev/null +++ b/plans/menudet-jit-inline-comparisons.json @@ -0,0 +1,16663 @@ +{ + "platform": "macOS-26.6.2-arm64-arm-64bit-Mach-O", + "numpy": "2.5.3", + "numexpr": "2.14.2", + "size": 262144, + "dtype": "float64", + "api": "flat", + "numexpr_threads": 1, + "technique": "Rotating workload/backend order; untimed warm-up; identical shared buffers", + "samples_per_process": { + "interpreter": 3, + "other_backends": 30 + }, + "compiler_versions": { + "gcc": "gcc-16 (Homebrew GCC 16.2.0) 16.2.0\nCopyright (C) 2026 Free Software Foundation, Inc.\nThis is free software; see the source for copying conditions. There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n", + "clang": "Apple clang version 21.0.0 (clang-2100.3.34.2)\nTarget: arm64-apple-darwin25.6.0\nThread model: posix\nInstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin\n" + }, + "summary": [ + { + "workload": "affine", + "backend": "interpreter", + "median_of_process_medians_ms": 1041.323333, + "process_medians_ms": [ + 1030.13925, + 1036.4105, + 1041.323333, + 1165.164875, + 1042.579125 + ] + }, + { + "workload": "affine", + "backend": "tcc", + "median_of_process_medians_ms": 0.6441045000000001, + "process_medians_ms": [ + 0.660438, + 0.6587295, + 0.6388545, + 0.6441045000000001, + 0.627667 + ] + }, + { + "workload": "affine", + "backend": "gcc", + "median_of_process_medians_ms": 0.2825205, + "process_medians_ms": [ + 0.3030835, + 0.2943125, + 0.27889549999999996, + 0.2825205, + 0.27972949999999996 + ] + }, + { + "workload": "affine", + "backend": "clang", + "median_of_process_medians_ms": 0.2526045, + "process_medians_ms": [ + 0.2745625, + 0.2526045, + 0.2486045, + 0.2452715, + 0.254896 + ] + }, + { + "workload": "affine", + "backend": "numpy", + "median_of_process_medians_ms": 0.3, + "process_medians_ms": [ + 0.3372505, + 0.30879199999999996, + 0.286646, + 0.279125, + 0.3 + ] + }, + { + "workload": "affine", + "backend": "numexpr", + "median_of_process_medians_ms": 0.361979, + "process_medians_ms": [ + 0.3807295, + 0.376229, + 0.3540625, + 0.35531250000000003, + 0.361979 + ] + }, + { + "workload": "polynomial", + "backend": "interpreter", + "median_of_process_medians_ms": 778.903542, + "process_medians_ms": [ + 773.312083, + 778.903542, + 776.0595, + 870.999042, + 780.6405 + ] + }, + { + "workload": "polynomial", + "backend": "tcc", + "median_of_process_medians_ms": 0.6462085, + "process_medians_ms": [ + 0.667, + 0.6395835000000001, + 0.6462085, + 0.6485, + 0.6062715 + ] + }, + { + "workload": "polynomial", + "backend": "gcc", + "median_of_process_medians_ms": 0.1471045, + "process_medians_ms": [ + 0.17447849999999998, + 0.1469165, + 0.140604, + 0.148542, + 0.1471045 + ] + }, + { + "workload": "polynomial", + "backend": "clang", + "median_of_process_medians_ms": 0.1175005, + "process_medians_ms": [ + 0.14327099999999998, + 0.1175005, + 0.114625, + 0.1137915, + 0.1202915 + ] + }, + { + "workload": "polynomial", + "backend": "numpy", + "median_of_process_medians_ms": 0.30322899999999997, + "process_medians_ms": [ + 0.322313, + 0.31162500000000004, + 0.30322899999999997, + 0.279354, + 0.2835 + ] + }, + { + "workload": "polynomial", + "backend": "numexpr", + "median_of_process_medians_ms": 0.3042505, + "process_medians_ms": [ + 0.3272705, + 0.3197915, + 0.3042505, + 0.301458, + 0.291958 + ] + }, + { + "workload": "where", + "backend": "interpreter", + "median_of_process_medians_ms": 915.256375, + "process_medians_ms": [ + 906.747667, + 913.233791, + 915.256375, + 968.035542, + 918.512833 + ] + }, + { + "workload": "where", + "backend": "tcc", + "median_of_process_medians_ms": 1.0254375, + "process_medians_ms": [ + 1.0403335, + 1.002542, + 1.0254375, + 1.0266875, + 1.0023125 + ] + }, + { + "workload": "where", + "backend": "gcc", + "median_of_process_medians_ms": 0.36202049999999997, + "process_medians_ms": [ + 0.373708, + 0.363479, + 0.3510625, + 0.355708, + 0.36202049999999997 + ] + }, + { + "workload": "where", + "backend": "clang", + "median_of_process_medians_ms": 0.323687, + "process_medians_ms": [ + 0.335333, + 0.32577100000000003, + 0.318125, + 0.323687, + 0.303396 + ] + }, + { + "workload": "where", + "backend": "numpy", + "median_of_process_medians_ms": 0.501333, + "process_medians_ms": [ + 0.5602499999999999, + 0.5477084999999999, + 0.48683299999999996, + 0.49008300000000005, + 0.501333 + ] + }, + { + "workload": "where", + "backend": "numexpr", + "median_of_process_medians_ms": 0.45025, + "process_medians_ms": [ + 0.4588545, + 0.4518335, + 0.45025, + 0.448125, + 0.4408545 + ] + } + ], + "processes": [ + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1030.13925 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.671458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.262584 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.247875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.394042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.389917 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 766.446 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.724542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.17725 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.137125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.377208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.409917 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 905.787791 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.063333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.402958 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.313 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.55575 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.453542 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.640291 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.137042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.108875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.231917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.306708 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 775.092834 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.014875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.345542 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.301208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.472 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.463125 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 907.6425 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.670709 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.277208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.244875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.404708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.40475 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1028.545542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.471708 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.287208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.528834 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.451042 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 906.747667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.1105 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.300083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.222625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.331625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.371292 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1039.508042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.737459 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.162 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.126834 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.28625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.350709 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 773.312083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.7425 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.374417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.374041 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.660166 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.277041 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.27625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.269916 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.345334 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.644917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.130041 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.106208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.506667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.457333 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.058209 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.33475 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.301167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.2865 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.632792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.156917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.106292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.253375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.441042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.98875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.3645 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.343125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.53825 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.338375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.638959 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.33725 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.22575 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.265916 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.013542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.428459 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.336542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.680541 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.537042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.760334 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.319541 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.286458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.374584 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.355417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.663709 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.174541 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.1375 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.338125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.353084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.276875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.227792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.235708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.312875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.592208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.121333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.09725 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.272958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.421125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.693833 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.313791 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.274083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.587875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.408292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.99 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.109042 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.2895 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.306041 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.675708 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.187084 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.356083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.54725 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.437958 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.015083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.36675 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.260458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.267083 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.378125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.683708 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.359833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.721916 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.458875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.044083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.434208 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.338583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.360875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.413791 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.597125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.301834 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.240042 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.293292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.335625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.6475 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.149375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.141625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.349542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.663208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.311083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.286583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.336167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.312042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.662916 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.183334 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.161416 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.358458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.449708 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.037958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.366292 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.324167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.730291 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.666125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.189 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.143417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.322417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.326459 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.054417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.419125 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.370292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.6395 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.494667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.707334 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.299375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.291 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.35475 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.399417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.391292 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.326625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.617292 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.463208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.98825 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.323042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.265542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.385625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.401792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.64425 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.145333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.120375 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.276209 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.293416 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.628667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.275834 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.327417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.406625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.655958 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.277958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.144208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.301375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.301125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.648041 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.179583 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.307834 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.551875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.438083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.995708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.371542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.345208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.32475 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.658166 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.174792 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.159708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.56475 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.506584 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.071625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.383625 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.334583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.34225 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.383125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.65625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.298708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.307166 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.465208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.057917 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.388208 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.348458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.578292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.3725 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.659875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.305417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.27975 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.323333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.32625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.689833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.179125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.149334 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.314792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.653458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.31475 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.274667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.313875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.37125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.69525 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.174416 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.147875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.326083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.357708 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.013792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.379333 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.425959 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.655625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.497791 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.209541 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.178375 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.362042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.341917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.70575 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.376542 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.351167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.565083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.474042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.059334 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.294583 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.267208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.350625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.382375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.660292 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.336083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.5195 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.45175 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.04125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.3725 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.276 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.344834 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.406875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.659125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.31 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.146834 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.351542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.3565 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.678416 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.181083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.307125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.383084 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.660584 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.296667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.28 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.346167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.350583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.694958 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.184333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.144041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.573875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.455791 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.040375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.366583 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.325042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.3335 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.716583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.186 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.154 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.465667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.474 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.102791 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.374291 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.31825 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.626375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.375916 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.663667 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.286417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.305125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.374875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.04125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.374459 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.329417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.537583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.458834 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.701875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.304667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.270167 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.320459 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.385541 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.656125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.167667 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.170917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.373375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.327416 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.314417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.262666 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.358917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.377041 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.668542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.163625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.136541 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.309875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.323833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.667875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.366541 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.348875 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.576917 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.462667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.0615 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.143125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.317208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.315875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.662375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.166125 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.340791 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.529 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.455458 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.03575 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.372333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.26875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.317708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.373417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.649083 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.304333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.506209 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.443959 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.067125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.380542 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.33875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.369334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.398792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.691458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.292959 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.23775 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.291291 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.327125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.67575 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.173042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.142459 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.373459 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.666666 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.312792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.274458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.286292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.311875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.650833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.163459 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.128 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.319209 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.458 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.023 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.357833 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.331791 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.55125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.713583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.164209 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.145125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.324375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.328375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.032667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.370167 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.338084 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.537458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.462834 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.65575 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.311959 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.278417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.317291 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.381459 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.399 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.345667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.564875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.476917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.01675 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.284375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.252917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.299792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.368959 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.643208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.162292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.140291 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.322209 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.317 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.689875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.279083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.31175 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.385584 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.663958 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.296 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.157417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.388666 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.3145 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.652334 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.174833 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.3345 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.640125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.489125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.040292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.373125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.362042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.338334 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.703834 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.175625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.153 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.492 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.43575 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.041042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.395084 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.357833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.338334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.390958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.662583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.308708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.283166 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.469791 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.006083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.352416 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.322083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.509 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.38 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.645583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.324041 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.277291 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.380625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.332083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.659166 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.212958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.220667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.401584 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.035875 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 2.85025 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 385.600125 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 365.787625 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.076333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 8.774375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 406.299542 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 384.44425 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.215 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 8.204041 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 406.216708 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 372.34525 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a036d40d1782f61be92eb2555bc217ec2d6396aa54472c374eec65c4e1d05ad2" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1036.4105 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.79925 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.280417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.275667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.335833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.447375 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 778.234417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.741167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.180708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.137125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.342 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.352291 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 908.439042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.999458 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.405584 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.308 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.558916 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.453291 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.620333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.160334 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.142583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.311666 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.317666 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 786.845292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.157125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.401125 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.369 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.667167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.547916 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 913.732084 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.7165 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.307959 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.333959 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.38625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.397584 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1043.038667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.439208 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.320583 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.554333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.494042 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 913.233791 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.079292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.311791 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.354709 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.307625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.406333 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1035.495084 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.811542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.167625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.138125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.371875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.34875 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 778.903542 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.702792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.373958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.399334 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.70725 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.30325 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.289792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.358541 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.311791 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.655917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.147791 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.124542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.52175 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.483417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.044875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.440084 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.308208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.336958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.618959 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.13925 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.102417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.30975 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.452292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.999084 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.372667 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.378708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.7135 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.43425 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.71125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.287458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.2115 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.262667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.025083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.331375 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.301959 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.438709 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.420917 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.607125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.272375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.242375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.278833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.344167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.632875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.184292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.15725 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.391375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.344584 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.336458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.287417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.320084 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.356833 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.641166 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.183958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.151834 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.290292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.309291 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.694459 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.431166 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.376042 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.550875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.408083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.994584 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.117709 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.248792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.352375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.648084 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.146042 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.275333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.593625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.455542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.997708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.328959 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.235667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.284542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.34525 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.633792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.259708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.443333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.430875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.990041 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.331542 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.376666 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.259833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.388667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.696167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.309708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.304041 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.3535 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.34525 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.633166 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.151083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.130375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.386583 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.739417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.3415 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.287209 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.384375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.320208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.64725 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.126459 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.102583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.237292 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.447625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.083667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.364292 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.28775 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.625667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.614917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.125667 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.108542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.279833 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.290209 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.039959 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.32775 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.291083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.468958 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.438291 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.679416 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.293417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.237042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.339875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.35 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.330792 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.318208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.669042 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.4765 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.048375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.295208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.2505 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.313375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.352875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.615167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.17525 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.143833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.283667 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.293208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.637792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.271666 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.287083 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.401459 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.677334 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.285167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.099 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.276583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.270959 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.651208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.168917 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.342375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.524667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.408209 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.001959 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.376708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.344166 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.353834 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.613041 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.124375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.116917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.425458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.411834 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.999958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.372875 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.358083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.374958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.390583 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.698125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.362458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.323208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.539708 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.016167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.371708 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.339292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.631458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.360167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.67625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.306709 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.238 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.326625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.34 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.627167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.126792 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.112125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.315375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.588 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.263541 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.223459 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.350458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.374708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.589 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.142875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.104666 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.252708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.283791 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.9945 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.318 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.287083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.53475 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.41725 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.126625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.104792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.250208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.278667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.625334 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.382125 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.298041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.42225 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.443291 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.029209 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.319416 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.271708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.334667 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.392459 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.687333 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.326834 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.544542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.475 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.99725 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.346792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.241125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.307416 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.35075 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.636959 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.288958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.117292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.278375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.343333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.641375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.134667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.253458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.354 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.650666 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.399209 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.345208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.327292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.351709 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.575458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.143875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.091292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.5225 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.398917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.962125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.345083 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.33625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.3565 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.69475 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.141209 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.106209 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.3015 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.437792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.094834 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.371334 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.359375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.530167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.409667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.675 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.307166 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.254709 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.309959 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.038084 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.364583 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.30625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.649542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.470584 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.636667 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.272042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.2385 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.29525 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.382458 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.664625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.15675 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.138875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.314125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.301084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.268833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.235709 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.231083 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.368625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.640459 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.139542 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.102541 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.2235 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.30275 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.629 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.337458 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.299375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.554416 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.477 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.102208 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.146958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.338041 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.300667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.664458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.236792 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.35425 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.672667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.469875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.994791 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.346083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.23525 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.254833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.360833 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.619125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.265583 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.412375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.451375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.994959 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.362666 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.340291 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.256125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.393791 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.634584 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.308 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.244416 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.330417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.305209 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.591583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.134333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.102125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.345625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.66175 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.307917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.285959 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.328 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.349875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.619916 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.12425 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.10425 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.339625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.447917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.003625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.357792 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.34475 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.683084 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.713666 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.231583 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.164125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.388083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.324042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.977625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.373083 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.353792 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.513125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.468208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.622208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.284042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.245625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.243125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.37775 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.339625 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.298 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.410541 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.42325 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.99475 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.264 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.267 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.22825 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.366166 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.649125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.1565 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.132167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.286875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.319375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.636208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.226292 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.239834 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.358875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.655709 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.29075 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.136542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.311584 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.31025 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.661167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.17775 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.384834 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.603791 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.503833 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.074167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.370209 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.354041 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.325 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.682375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.14375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.100791 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.491167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.428833 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.995959 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.332333 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.303708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.344583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.415208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.696583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.278541 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.240708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.458458 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.003125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.349875 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.324708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.557334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.363042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.617625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.312167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.261958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.340708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.28175 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.642792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.15525 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.143292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.288208 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.0335 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 2.802375 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 391.185292 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 366.507708 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.065084 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 6.585625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 413.305625 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 373.49375 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.045333 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 1.531834 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 380.787417 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 369.95125 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a036d40d1782f61be92eb2555bc217ec2d6396aa54472c374eec65c4e1d05ad2" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1037.058625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.729583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.2965 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.253292 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.377084 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.35 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 774.717542 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.69925 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.139833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.139833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.289625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.315584 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 910.714166 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.067666 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.343083 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.2985 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.532583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.471125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.652541 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.147958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.125041 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.268958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.344375 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 776.0595 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.112292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.365041 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.334166 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.569875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.46325 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 916.038792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.678709 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.272 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.247042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.287625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.376208 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1041.558083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.428625 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.320167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.559625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.467333 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 915.256375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.122167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.310709 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.289667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.310125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.425791 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1041.323333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.7 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.146541 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.10175 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.315125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.318416 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 776.813083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.719417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.285667 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.402667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.647208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.289667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.261708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.300666 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.321084 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.673916 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.13575 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.108708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.433167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.425417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.037584 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.381208 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.322375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.295792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.629541 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.123375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.097708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.261667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.425958 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.944125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.339667 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.318791 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.514875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.358792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.621292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.291041 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.241958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.277625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.0535 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.371208 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.341167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.555417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.490417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.664125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.286125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.233708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.311375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.350416 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.603166 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.133 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.108625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.284333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.293708 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.284 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.225375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.235417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.328583 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.632375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.123459 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.1065 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.267834 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.280333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.628208 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.32775 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.298125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.479208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.443917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.042416 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.134709 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.32075 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.320667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.682625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.174375 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.333584 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.601167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.459125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.024375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.342083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.2485 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.2585 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.345333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.663792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.301292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.505333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.466 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.017958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.339291 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.311708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.303417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.369208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.642375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.258625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.2425 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.296 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.328375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.606708 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.140125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.100375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.308458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.601 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.244083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.233208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.248333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.305417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.638083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.158083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.107333 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.250209 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.442625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.071708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.34875 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.295458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.444417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.669625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.173208 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.134959 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.309709 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.304041 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.037459 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.420208 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.370708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.473792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.470958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.664459 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.296709 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.27225 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.307958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.38025 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.359667 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.31225 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.482458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.44975 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.020083 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.2975 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.256416 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.342708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.337416 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.614417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.133458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.106125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.281333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.35225 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.693917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.248709 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.304166 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.354708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.617375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.258625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.107084 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.254334 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.304209 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.651375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.132209 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.303208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.486375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.446542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.0265 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.358167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.259166 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.290708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.645792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.17375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.148834 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.563333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.473625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.098 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.366333 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.355875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.425333 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.36325 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.624375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.271167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.242458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.422666 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.012291 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.345042 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.299584 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.478625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.347625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.621584 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.273167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.257584 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.284791 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.301542 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.646625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.1335 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.106334 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.255167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.623333 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.258084 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.258292 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.317041 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.363041 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.650917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.180833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.127334 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.303583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.291875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.954334 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.378125 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.319 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.465292 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.451625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.134417 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.10125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.314333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.282084 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.670167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.360417 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.333375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.532875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.463167 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.032833 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.277541 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.2385 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.277625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.344417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.655416 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.3275 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.484291 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.407125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.0515 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.368083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.245708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.325542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.351875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.623083 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.257959 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.109958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.322083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.301708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.636125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.137083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.259875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.359375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.660625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.28025 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.252125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.298292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.309333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.638375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.133042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.131166 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.487291 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.435333 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.959708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.30725 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.288791 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.339917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.6605 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.152417 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.122458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.34625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.456416 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.9685 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.35175 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.299042 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.59525 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.337792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.653334 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.285625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.258667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.296125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.002291 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.342792 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.355542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.639 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.45075 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.5895 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.244 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.214709 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.301625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.332208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.624041 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.144625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.124542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.316125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.345625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.292458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.265375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.312625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.381041 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.664042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.162958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.140333 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.337208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.287958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.635917 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.328167 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.317958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.528583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.46575 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.042041 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.159041 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.3335 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.290667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.578542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.144833 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.302667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.445875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.432042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.001625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.3405 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.236084 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.280042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.359083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.64375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.252542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.424625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.429625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.009666 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.342625 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.310167 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.260333 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.404583 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.629292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.297459 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.24725 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.316458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.305833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.641833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.12925 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.135833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.33675 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.624167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.25975 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.243833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.280583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.289042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.639916 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.151375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.116083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.315667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.461125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.037834 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.350375 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.318292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.46775 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.648708 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.141083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.11775 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.31975 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.304292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.007542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.386375 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.293958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.432083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.438208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.618916 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.267625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.249708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.270958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.340667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.330791 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.316541 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.477709 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.430375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.001333 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.318625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.278459 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.3135 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.368417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.657042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.17125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.121458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.333541 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.321209 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.668458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.253292 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.263625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.353417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.601292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.296917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.113167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.296583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.358958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.673292 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.157833 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.3385 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.494792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.4405 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.004625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.353375 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.328709 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.303083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.635916 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.130708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.107125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.524666 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.448583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.029417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.33575 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.315875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.261166 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.338167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.6455 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.266 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.265709 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.454375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.016083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.362167 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.361792 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.433 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.361792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.635334 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.268666 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.23275 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.25675 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.288 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.6335 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.133917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.106542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.302875 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.032875 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 2.836 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 414.631792 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 379.026917 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.117334 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 6.689625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 407.783583 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 376.541875 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.145416 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 6.320208 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 417.615417 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 374.663083 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a036d40d1782f61be92eb2555bc217ec2d6396aa54472c374eec65c4e1d05ad2" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1109.122542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.686958 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.281542 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.235125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.276042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.356625 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 916.823917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.675458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.211709 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.135042 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.302417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.332583 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 949.148916 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.121583 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.365416 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.339166 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.62425 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.504458 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.658542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.144 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.113542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.251708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.307166 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 870.999042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.06575 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.333708 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.311666 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.500917 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.447583 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 970.329542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.668667 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.290958 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.273708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.312042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.425958 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1195.315083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.389292 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.294 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.57475 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.426791 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 968.035542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.112875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.304584 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.250375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.293083 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.394417 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1165.164875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.716416 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.19725 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.139209 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.310125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.320708 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 851.140583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.770209 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.333459 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.365792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.636709 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.264125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.245459 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.28775 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.299166 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.644666 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.140334 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.101417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.545292 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.483959 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.015292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.348666 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.296959 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.291958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.621667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.148584 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.106792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.248208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.433625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.019083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.345459 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.34075 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.554125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.372958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.686 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.31225 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.264334 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.305 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.059917 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.364625 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.336209 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.510875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.460167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.664333 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.281584 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.258417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.264792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.362792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.65975 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.136666 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.101625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.249375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.289541 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.282333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.245084 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.305125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.351708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.628458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.128708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.106584 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.281208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.293208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.6335 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.33825 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.295375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.421542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.492959 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.00025 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.106667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.260833 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.315916 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.647875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.16775 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.332542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.481125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.444542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.059084 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.37275 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.27625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.302625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.38125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.645584 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.283167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.478583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.441 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.004083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.3555 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.301959 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.234125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.343333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.614042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.275542 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.294083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.250041 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.286125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.622333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.13675 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.10625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.346375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.621458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.282708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.230458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.248625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.284917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.642958 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.150666 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.101125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.2495 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.424875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.040625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.341333 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.300708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.43225 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.639875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.134959 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.107292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.2435 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.300666 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.015167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.332959 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.311541 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.494667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.485042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.673667 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.298 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.269542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.296833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.3715 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.402875 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.339666 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.573666 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.467875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.056292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.263791 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.236584 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.256833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.353375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.6275 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.134917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.107708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.285958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.294417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.646083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.234125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.268667 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.3825 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.64875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.298583 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.149417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.333917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.322792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.662875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.134166 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.301667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.472625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.426 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.999916 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.382833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.27775 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.2985 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.620625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.133625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.106292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.49275 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.467166 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.0665 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.383542 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.323833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.289875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.34975 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.649208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.308125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.273917 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.437167 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.007 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.364625 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.350458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.434291 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.344916 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.639459 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.270584 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.226916 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.270417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.286333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.632958 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.195875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.11725 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.259 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.6175 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.263083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.231583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.320458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.351709 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.651333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.159084 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.125459 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.269625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.297125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.007292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.333375 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.315458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.487416 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.446666 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.15425 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.132125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.300292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.34 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.680875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.380917 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.344416 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.535833 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.464167 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.031625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.283125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.252833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.255 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.394458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.631125 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.300667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.429833 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.453125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.043292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.370459 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.250958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.291292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.373625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.642625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.262209 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.109458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.264208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.310875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.624917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.1335 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.247334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.343958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.623458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.262333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.251041 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.248958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.287125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.625417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.138666 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.152667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.440708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.42875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.044375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.377792 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.358792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.327 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.68675 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.166125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.114041 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.302167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.434042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.996333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.341583 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.313791 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.461625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.358209 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.64675 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.262792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.236333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.236958 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.012 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.349166 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.301208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.441875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.432333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.674625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.344292 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.310375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.315208 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.371833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.7045 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.161916 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.1575 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.344375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.296625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.269083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.244875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.253833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.339167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.628833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.134375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.10525 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.250666 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.293375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.662875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.365541 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.345041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.563417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.487208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.050167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.147125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.355958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.3285 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.649125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.162333 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.325375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.679792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.48 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.080333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.355916 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.235292 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.318708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.34825 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.641125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.286292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.49675 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.448667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.027708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.333084 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.323541 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.249167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.339625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.627083 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.262583 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.231833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.253458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.324166 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.653542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.137541 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.107334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.340375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.630917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.266959 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.306333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.3145 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.326833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.677875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.162667 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.132125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.289459 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.492166 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.076667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.387208 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.327958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.483041 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.625375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.1485 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.118875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.284708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.296875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.017333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.337125 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.318958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.459042 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.449209 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.666416 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.272625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.242625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.235583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.344916 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.353209 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.298208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.423333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.442208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.012 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.282792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.23375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.263417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.347459 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.633458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.134833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.141083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.332459 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.377333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.635792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.258958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.282208 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.359167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.656833 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.319375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.146292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.357875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.326084 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.658959 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.170625 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.332166 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.541625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.452292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.025667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.340792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.266416 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.30225 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.633917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.156042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.106917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.421875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.430792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.001708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.329541 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.331459 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.258292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.354 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.684458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.33075 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.230334 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.410125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.958167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.372333 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.352125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.649333 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.356625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.653167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.298833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.242792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.283666 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.331291 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.651291 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.153 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.1315 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.280958 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.034834 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 2.900459 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 392.120875 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 374.956458 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.101875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 9.572459 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 413.3255 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 389.722417 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.164125 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 7.455875 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 416.384834 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 372.004916 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a036d40d1782f61be92eb2555bc217ec2d6396aa54472c374eec65c4e1d05ad2" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1042.086709 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.707959 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.329959 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.231875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.336666 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.383625 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 781.040666 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.70525 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.185083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.164083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.3525 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.400792 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 919.277167 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.0855 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.366708 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.349625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.67325 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.488417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.598417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.140708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.117125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.262208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.3015 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 777.926542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.124 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.418042 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.34625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.624833 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.47825 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 918.512833 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.735708 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.297084 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.264458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.365792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.393416 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1048.900292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.373042 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.287875 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.5015 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.447375 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 914.675459 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.042125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.262833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.2555 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.35675 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.359542 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1042.579125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.698875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.16025 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.143667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.382125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.356208 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 780.6405 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.710417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.330542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.43175 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.671083 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.287875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.251791 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.270959 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.302583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.57725 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.151458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.140375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.499584 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.429833 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.99325 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.337666 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.2975 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.298459 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.61975 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.158459 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.140417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.318625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.455209 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.011542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.361666 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.308417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.569334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.370792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.649167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.254667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.254708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.256542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.980042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.333542 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.301916 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.418459 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.419 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.629 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.264334 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.257333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.299625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.376875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.631208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.161458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.148 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.333916 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.32425 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.300917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.278125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.339583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.373458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.625667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.13825 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.118916 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.279125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.287167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.639292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.354584 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.295167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.542167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.418459 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.002458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.110792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.25 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.283042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.600875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.168125 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.341667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.673 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.440584 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.981875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.310917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.205333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.24475 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.33775 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.602959 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.239875 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.434417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.412291 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.982333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.412459 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.301333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.295708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.406167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.60675 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.29225 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.291833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.335458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.344042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.723959 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.151834 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.174208 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.39425 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.589417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.251542 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.255417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.35175 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.270667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.567291 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.125375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.09925 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.236583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.415833 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.978375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.378333 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.359541 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.501166 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.608292 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.149584 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.109042 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.281542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.3045 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.975292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.333041 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.282042 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.451083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.42925 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.614042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.312292 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.261291 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.329167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.389083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.365541 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.318583 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.530417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.448458 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.033917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.316 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.264042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.376958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.400708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.659583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.150625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.1275 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.295208 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.289292 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.606084 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.231959 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.289791 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.355709 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.631834 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.289084 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.131416 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.285458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.291583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.596375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.121292 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.3045 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.440958 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.492042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.984333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.335833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.303375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.297042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.572542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.12075 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.106625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.450291 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.42225 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.983375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.342625 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.286916 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.263958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.3605 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.637792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.2935 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.263 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.441125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.019417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.351917 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.329167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.523709 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.378333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.623 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.268292 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.238834 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.298583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.284833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.603041 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.137625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.106833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.254459 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.612667 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.278792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.219625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.257625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.336709 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.602209 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.137959 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.106125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.2635 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.28875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.062125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.380542 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.29075 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.525875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.415667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.180875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.136292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.298792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.292333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.606459 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.33875 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.288666 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.470708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.427875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.997 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.329 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.265708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.306917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.363458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.650625 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.353625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.538208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.467458 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.069792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.37075 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.300875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.342542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.345584 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.569042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.277458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.129541 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.296 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.305583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.634167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.127792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.228625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.349417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.601208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.262125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.23875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.265792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.281 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.5915 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.125208 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.097958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.441625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.459792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.988459 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.411833 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.336708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.31675 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.636333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.145792 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.121667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.2705 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.426458 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.038667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.364833 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.301375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.50375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.352583 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.628834 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.287791 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.264375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.303667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.056416 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.3665 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.302292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.463334 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.429125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.608 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.274417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.27325 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.364292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.359709 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.5795 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.137292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.097625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.231417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.261875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.235875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.220542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.233834 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.338333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.612208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.159291 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.12225 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.311542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.290542 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.605209 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.330667 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.287958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.426625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.424834 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.988542 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.122209 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.254083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.285125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.608834 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.148417 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.301708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.515875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.435333 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.9775 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.379666 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.255084 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.258959 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.387542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.656292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.301666 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.560334 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.454542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.041708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.362375 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.305 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.301917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.380083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.635459 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.271833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.25075 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.290583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.276292 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.567875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.137833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.11175 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.341375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.6265 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.280667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.248416 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.298042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.285041 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.628667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.135333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.124417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.288084 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.42825 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.045333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.358334 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.318792 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.531708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.594416 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.139834 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.118583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.292708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.298875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.030291 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.365166 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.307042 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.4965 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.456375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.66375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.303792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.263 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.300375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.359708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.334708 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.30125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.479166 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.447458 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.990875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.260666 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.224417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.28375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.356083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.600458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.124875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.113125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.244458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.277792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.641 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.2255 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.241958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.35475 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.60425 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.291083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.112042 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.244375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.292667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.623083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.151375 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.331625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.537875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.450583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.002167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.359 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.311791 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.295083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.647125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.169042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.132292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.442792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.457666 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.059875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.36325 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.320083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.302166 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.3705 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.654083 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.273667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.232125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.450084 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.988833 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.333875 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.2875 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.437417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.346084 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.619834 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.259959 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.225666 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.250584 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.273291 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.598625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.149 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.1065 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.252292 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.032375 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 3.085666 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 391.7335 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 381.27475 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.117708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 7.597958 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 404.072916 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 378.749416 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.251792 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 11.686459 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 407.740417 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 381.654083 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "a036d40d1782f61be92eb2555bc217ec2d6396aa54472c374eec65c4e1d05ad2" + } + ], + "limitations": [ + "No core affinity or frequency tracing; not proof of the prior timing cause.", + "Finite C-contiguous workloads; compilation excluded from warm timings.", + "Interpreter has a smaller sample budget and participates in initial rounds only." + ] +} diff --git a/plans/menudet-jit-interleaved.json b/plans/menudet-jit-interleaved.json new file mode 100644 index 000000000..6b23da447 --- /dev/null +++ b/plans/menudet-jit-interleaved.json @@ -0,0 +1,16663 @@ +{ + "platform": "macOS-26.6.2-arm64-arm-64bit-Mach-O", + "numpy": "2.5.3", + "numexpr": "2.14.2", + "size": 262144, + "dtype": "float64", + "api": "flat", + "numexpr_threads": 1, + "technique": "Rotating workload/backend order; untimed warm-up; identical shared buffers", + "samples_per_process": { + "interpreter": 3, + "other_backends": 30 + }, + "compiler_versions": { + "gcc": "gcc-16 (Homebrew GCC 16.2.0) 16.2.0\nCopyright (C) 2026 Free Software Foundation, Inc.\nThis is free software; see the source for copying conditions. There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n", + "clang": "Apple clang version 21.0.0 (clang-2100.3.34.2)\nTarget: arm64-apple-darwin25.6.0\nThread model: posix\nInstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin\n" + }, + "summary": [ + { + "workload": "affine", + "backend": "interpreter", + "median_of_process_medians_ms": 1010.738375, + "process_medians_ms": [ + 992.382458, + 1003.088959, + 1010.738375, + 1018.509792, + 1027.926834 + ] + }, + { + "workload": "affine", + "backend": "tcc", + "median_of_process_medians_ms": 0.640458, + "process_medians_ms": [ + 0.640458, + 0.6398955, + 0.642979, + 0.652146, + 0.638 + ] + }, + { + "workload": "affine", + "backend": "gcc", + "median_of_process_medians_ms": 0.283937, + "process_medians_ms": [ + 0.277604, + 0.2863545, + 0.276167, + 0.28829150000000003, + 0.283937 + ] + }, + { + "workload": "affine", + "backend": "clang", + "median_of_process_medians_ms": 0.250021, + "process_medians_ms": [ + 0.250021, + 0.253417, + 0.2453955, + 0.261917, + 0.2473125 + ] + }, + { + "workload": "affine", + "backend": "numpy", + "median_of_process_medians_ms": 0.3017705, + "process_medians_ms": [ + 0.302062, + 0.3017915, + 0.298083, + 0.297812, + 0.3017705 + ] + }, + { + "workload": "affine", + "backend": "numexpr", + "median_of_process_medians_ms": 0.3675, + "process_medians_ms": [ + 0.358229, + 0.360625, + 0.3675, + 0.3690835, + 0.37093750000000003 + ] + }, + { + "workload": "polynomial", + "backend": "interpreter", + "median_of_process_medians_ms": 758.753, + "process_medians_ms": [ + 744.681125, + 749.598333, + 758.753, + 759.180875, + 776.47325 + ] + }, + { + "workload": "polynomial", + "backend": "tcc", + "median_of_process_medians_ms": 0.6462915, + "process_medians_ms": [ + 0.6462915, + 0.6488335000000001, + 0.643562, + 0.6498545, + 0.6421874999999999 + ] + }, + { + "workload": "polynomial", + "backend": "gcc", + "median_of_process_medians_ms": 0.1525415, + "process_medians_ms": [ + 0.14991700000000002, + 0.158646, + 0.149896, + 0.156646, + 0.1525415 + ] + }, + { + "workload": "polynomial", + "backend": "clang", + "median_of_process_medians_ms": 0.1266875, + "process_medians_ms": [ + 0.1274165, + 0.1315625, + 0.12331249999999999, + 0.1266875, + 0.1204585 + ] + }, + { + "workload": "polynomial", + "backend": "numpy", + "median_of_process_medians_ms": 0.28489600000000004, + "process_medians_ms": [ + 0.29510349999999996, + 0.306458, + 0.2838745, + 0.28489600000000004, + 0.282271 + ] + }, + { + "workload": "polynomial", + "backend": "numexpr", + "median_of_process_medians_ms": 0.307792, + "process_medians_ms": [ + 0.3070835, + 0.307792, + 0.308021, + 0.3085415, + 0.3051875 + ] + }, + { + "workload": "where", + "backend": "interpreter", + "median_of_process_medians_ms": 894.044292, + "process_medians_ms": [ + 874.440959, + 883.277709, + 894.044292, + 897.484542, + 906.57425 + ] + }, + { + "workload": "where", + "backend": "tcc", + "median_of_process_medians_ms": 1.038354, + "process_medians_ms": [ + 1.0292085, + 1.038354, + 1.0368125, + 1.0504375, + 1.0507705 + ] + }, + { + "workload": "where", + "backend": "gcc", + "median_of_process_medians_ms": 0.728333, + "process_medians_ms": [ + 0.728333, + 0.725833, + 0.7251875, + 0.734229, + 0.732 + ] + }, + { + "workload": "where", + "backend": "clang", + "median_of_process_medians_ms": 0.7169165, + "process_medians_ms": [ + 0.7184585, + 0.7169165, + 0.7092080000000001, + 0.72325, + 0.7143335 + ] + }, + { + "workload": "where", + "backend": "numpy", + "median_of_process_medians_ms": 0.5230205, + "process_medians_ms": [ + 0.5230205, + 0.5390630000000001, + 0.508375, + 0.523417, + 0.5042709999999999 + ] + }, + { + "workload": "where", + "backend": "numexpr", + "median_of_process_medians_ms": 0.441438, + "process_medians_ms": [ + 0.4405835, + 0.442167, + 0.441438, + 0.45583300000000004, + 0.4404585 + ] + } + ], + "processes": [ + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 992.382458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.676292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.302375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.243541 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.282042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.380125 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 742.598292 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.658667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.130542 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.113916 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.2685 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.318333 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 874.440959 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.080333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.747291 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.725625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.630167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.469 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.633125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.157625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.118625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.276167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.304666 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 747.237208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.083666 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.730166 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.702041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.610167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.438125 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 873.565959 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.703291 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.303791 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.267584 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.313167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.377042 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 997.383792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.762458 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.72075 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.601375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.461708 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 875.401708 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.067292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.2695 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.232583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.285 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.358708 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 989.347667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.717042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.168791 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.127125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.279291 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.330459 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 744.681125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.664958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.301333 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.395709 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.645375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.299375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.267958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.301209 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.348583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.67975 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.188667 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.163291 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.577667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.448375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.033333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.736166 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.736375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.3075 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.641709 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.138583 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.1255 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.27625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.42075 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.064542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.782792 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.743833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.623292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.390209 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.63775 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.29425 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.256375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.302791 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.02925 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.7755 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.738834 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.614666 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.431834 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.608583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.288833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.231125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.300917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.336625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.636833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.157959 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.133834 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.280334 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.298542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.289792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.240042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.2745 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.358708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.6445 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.15575 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.134458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.297875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.306875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.6775 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.7265 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.744709 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.6065 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.472375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.062958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.164291 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.349125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.325459 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.64575 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.162875 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.672209 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.527584 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.430125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.9855 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.701208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.244125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.321292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.352875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.629375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.274375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.513792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.432833 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.003042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.695417 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.698583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.412917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.334625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.585167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.256875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.239666 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.290209 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.306125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.605709 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.152792 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.119958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.33375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.633458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.260334 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.254625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.301167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.292417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.669709 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.1545 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.130416 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.301125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.46175 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.973875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.674042 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.719375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.522708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.646833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.140667 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.136 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.285708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.307292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.005209 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.703292 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.717542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.537417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.436584 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.634458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.26975 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.238833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.269125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.344625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.733083 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.686 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.499583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.428291 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.9875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.268834 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.263125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.29875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.377 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.613167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.150709 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.120667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.292666 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.339792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.66275 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.254417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.331792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.332375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.622084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.298375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.1365 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.297541 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.287625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.616084 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.1325 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.703542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.557917 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.45375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.079708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.800375 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.397458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.33125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.664916 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.148459 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.125292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.480042 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.46225 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.026 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.707 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.707125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.287791 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.342542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.626875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.290125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.2855 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.4485 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.024083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.706042 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.7265 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.555417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.362709 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.648625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.276125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.245708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.318083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.302833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.637417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.149125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.133916 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.300791 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.674334 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.279417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.263416 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.307041 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.339 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.638625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.129417 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.162708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.388542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.287666 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.978875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.674166 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.726708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.550583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.442667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.142208 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.12475 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.310417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.290084 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.629459 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.701916 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.723 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.49675 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.4385 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.013417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.322083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.254542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.331916 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.39475 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.613625 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.686917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.463083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.421042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.018792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.723084 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.250625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.318375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.35775 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.672167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.27625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.117834 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.356041 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.315167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.638416 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.148666 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.276 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.359458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.624958 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.277 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.220125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.2875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.283625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.589667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.121875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.162417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.541625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.394459 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.000375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.746458 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.699958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.307666 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.62475 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.138708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.131209 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.335167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.458 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.032291 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.707791 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.698667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.509083 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.373834 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.645875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.269792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.244458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.355583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.045875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.755208 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.717167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.523333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.471917 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.635125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.278208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.246125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.26375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.353958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.609125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.132083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.115333 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.249125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.314875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.27275 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.249417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.2725 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.378416 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.667542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.158958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.116792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.289291 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.293625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.657791 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.755917 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.7555 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.555625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.460291 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.029167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.118084 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.313 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.304958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.6715 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.16675 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.710334 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.515667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.454084 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.108042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.742208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.259875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.330125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.356625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.569792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.237584 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.483667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.406416 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.976792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.681292 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.6975 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.231167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.360708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.589875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.264708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.2105 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.266 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.288667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.648916 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.136875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.108209 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.356417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.655375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.338875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.273584 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.377167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.329167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.640875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.164958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.186875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.327125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.432834 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.026125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.703666 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.731167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.4825 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.659125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.149042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.128291 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.285417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.280959 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.064917 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.74 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.74575 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.514584 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.407667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.607667 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.266708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.245833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.288292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.331709 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.753125 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.743042 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.521834 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.436958 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.077208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.286333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.279959 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.319541 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.365583 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.666375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.164209 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.127708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.2665 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.332375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.673667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.26075 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.307167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.379375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.658833 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.294916 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.197167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.32725 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.336083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.666125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.17 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.712834 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.463917 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.454042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.071791 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.736708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.301458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.286083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.685291 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.167875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.123417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.510375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.419792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.983125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.68575 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.707458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.254625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.357 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.667042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.301458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.338708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.4675 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.051792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.708541 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.736584 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.489375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.355042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.643166 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.275542 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.229334 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.321041 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.331208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.606833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.145167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.110458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.274666 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.037791 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 2.801917 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 625.44975 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 368.148792 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.155667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 10.531458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 403.92125 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 401.796375 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.207666 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 7.7635 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 431.610041 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 365.517875 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 999.211625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.689583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.286667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.22325 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.290542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.396917 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 749.598333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.719667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.186833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.132417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.336375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.355042 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 883.277709 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.048292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.715708 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.695667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.574792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.474125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.649458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.156125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.132 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.325834 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.3155 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 747.564375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.123375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.72625 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.717375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.566625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.456959 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 884.3405 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.714125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.300875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.280958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.416417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.479625 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1003.088959 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.713542 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.710542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.655375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.496667 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 880.963542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.088917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.2785 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.248209 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.301458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.389333 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1017.464042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.705417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.164791 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.121709 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.275917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.337458 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 755.40375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.707083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.361792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.406792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.655208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.311709 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.261125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.313709 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.355375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.6725 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.184708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.1625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.560083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.426709 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.985542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.684291 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.698625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.315042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.630583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.148625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.118292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.329375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.448333 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.034 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.724791 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.728708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.536792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.377959 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.638333 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.308583 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.2605 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.335416 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.015166 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.738625 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.72525 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.567625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.442542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.647875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.318375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.264958 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.344125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.37925 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.672666 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.1675 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.141042 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.293417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.3295 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.286042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.241792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.279958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.358833 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.63425 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.160208 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.147541 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.336375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.291125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.60225 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.656542 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.71225 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.587125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.416916 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.015375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.152416 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.310541 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.334875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.641834 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.157084 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.717125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.528542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.441792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.035792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.736417 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.288125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.375584 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.374458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.657625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.287 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.58225 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.475459 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.067292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.770291 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.744708 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.342458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.358208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.645166 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.282834 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.254875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.311917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.306791 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.648209 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.161334 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.141708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.351667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.664875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.288916 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.266542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.302125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.315916 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.660166 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.16075 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.137167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.339875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.452959 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.032333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.729708 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.716708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.562625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.701792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.166959 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.132833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.3495 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.309125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.060125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.762667 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.751958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.65875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.429333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.602084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.287792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.235 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.304667 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.3605 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.714125 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.727125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.540792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.462708 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.03075 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.282416 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.257166 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.299625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.406542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.639458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.152291 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.124458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.316333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.337958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.675875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.251959 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.334666 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.358167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.596125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.269833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.131125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.299791 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.299417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.63 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.184917 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.669375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.580541 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.447625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.065333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.73175 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.290292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.30775 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.637833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.161833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.132208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.487959 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.477375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.023125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.726417 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.7185 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.297 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.35925 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.644 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.283875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.266666 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.443125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.04475 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.7395 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.734084 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.534208 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.357542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.629334 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.293792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.243125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.27975 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.323208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.662375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.163084 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.138459 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.30775 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.636042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.319917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.322709 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.373458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.403208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.735917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.153 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.122542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.318792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.29825 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.041791 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.723375 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.713083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.620041 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.462 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.163917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.144167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.304875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.313625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.646583 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.712 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.747916 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.603208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.452333 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.04725 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.332416 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.308083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.3675 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.383625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.698542 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.733584 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.537334 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.447667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.017333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.745959 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.264542 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.324625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.382167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.640333 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.293125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.127708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.2905 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.315125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.634583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.152334 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.28925 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.36075 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.625291 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.272834 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.22925 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.30875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.307834 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.628541 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.134208 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.129667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.486708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.420917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.042542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.69575 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.7195 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.291791 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.642583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.124834 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.106667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.272375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.42675 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.02 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.70975 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.707333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.499583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.375625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.660709 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.306875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.26925 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.371375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.039542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.760208 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.718625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.529583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.428875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.634917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.287375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.238917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.297625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.348167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.637958 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.137292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.107708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.274084 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.279334 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.271083 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.233833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.246917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.352709 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.608333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.133458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.114666 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.247375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.291417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.6365 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.740292 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.702583 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.436291 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.429125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.038708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.13625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.287875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.2815 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.661334 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.131166 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.708083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.482041 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.4625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.067 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.750958 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.250625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.280416 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.352375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.620458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.279833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.440083 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.440917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.0695 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.734833 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.714459 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.285792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.373791 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.627167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.264291 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.233833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.278875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.282167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.674334 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.14725 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.121375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.354875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.617208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.268916 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.22525 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.256792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.27825 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.633458 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.130584 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.099208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.305166 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.44175 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.038 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.749041 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.742792 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.575416 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.672834 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.168958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.132667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.324459 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.301583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.024708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.710042 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.699125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.491625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.431792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.641875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.275625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.24725 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.333 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.354875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.699583 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.705625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.478334 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.4235 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.010667 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.2645 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.256167 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.268042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.343042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.627292 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.13375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.109417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.325792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.30425 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.643792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.232625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.266583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.332791 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.635417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.271708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.121042 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.290959 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.329208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.684 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.161 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.730458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.515416 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.439333 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.025292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.7085 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.2965 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.298 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.649708 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.156666 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.107375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.437708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.423417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.012583 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.707958 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.700792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.262834 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.359875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.643417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.293917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.255875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.439708 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.078834 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.725416 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.64975 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.561084 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.366125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.649417 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.260416 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.23875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.349291 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.289333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.625417 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.174084 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.1435 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.30125 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.031334 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 2.802 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 398.483917 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 355.600291 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.241375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 11.131834 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 408.936083 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 377.035333 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.110375 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 7.024791 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 413.323416 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 370.225541 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1012.223292 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.718167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.275625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.270042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.372917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.382583 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 758.753 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.650542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.140792 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.112083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.303625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.305459 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 900.277875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.129541 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.735791 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.731041 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.677167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.475042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.675625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.173709 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.142334 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.322958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.307459 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 758.134125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.104459 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.72325 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.694208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.66875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.471041 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 886.638417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.695333 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.269667 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.249792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.287833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.399125 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1009.573208 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.804084 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.704416 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.651 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.456333 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 894.044292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.121542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.27575 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.227541 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.28275 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.379666 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1010.738375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.715875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.191958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.147375 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.306083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.335916 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 768.193166 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.730459 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.312583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.404084 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.617792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.265625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.227291 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.254875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.290334 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.643125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.124375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.108166 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.5265 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.441292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.979375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.717875 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.670417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.321792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.608375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.148417 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.129125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.300209 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.408083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.012291 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.729084 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.736 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.577334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.3655 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.648416 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.2805 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.243875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.298625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.038959 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.727125 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.699542 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.499375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.428792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.616958 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.258625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.222 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.269833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.331333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.622958 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.136292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.098625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.231917 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.282875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.28875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.221792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.273583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.344375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.618333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.12725 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.105541 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.29525 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.273084 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.643541 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.686792 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.695167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.432625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.41775 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.083041 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.146875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.319875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.322167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.660542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.141042 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.696125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.445125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.425292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.043958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.736791 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.276375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.300958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.384291 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.668125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.304792 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.493875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.425875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.026209 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.720375 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.707666 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.285708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.354334 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.675084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.269292 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.232084 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.237416 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.284834 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.621917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.133167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.106042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.348334 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.618833 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.253917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.235709 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.324542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.309333 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.6505 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.166125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.13825 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.293583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.448833 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.062542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.721875 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.710958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.482375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.642167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.1405 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.11925 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.2965 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.297333 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.071291 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.727833 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.717708 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.438292 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.442083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.646459 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.281875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.290416 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.321125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.375583 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.732292 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.714209 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.453875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.441584 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.023792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.276042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.248917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.274708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.352542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.625709 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.127709 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.121125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.281292 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.319667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.645917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.289458 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.303042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.4115 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.6285 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.284375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.118125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.288458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.308583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.624083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.178292 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.724125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.5335 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.459542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.036208 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.715667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.258041 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.287709 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.601625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.163042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.12575 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.45325 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.419125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.02025 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.703208 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.709583 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.257917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.409375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.642375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.295875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.242458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.438042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.023625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.729041 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.732292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.517833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.386625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.657 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.276292 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.236125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.272792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.304959 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.692042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.173917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.130625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.276125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.643583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.271125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.237042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.262833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.359959 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.609917 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.155542 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.106792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.265375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.319625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.011542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.716333 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.78125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.525041 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.44175 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.141375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.12625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.301083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.310584 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.62225 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.700417 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.704333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.423209 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.446042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.054958 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.312792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.284417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.317166 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.397333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.6575 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.749 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.517375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.449792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.036959 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.764416 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.24775 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.312166 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.38925 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.68925 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.310542 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.145417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.339083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.315667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.644375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.15725 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.297541 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.340083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.65925 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.270792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.269208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.308791 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.299833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.677583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.173875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.140541 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.704709 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.434583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.964125 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.657583 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.684708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.278542 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.628583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.190125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.090083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.255 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.4245 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.015834 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.711833 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.689208 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.540791 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.381833 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.640625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.316708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.25725 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.440291 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.948625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.717375 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.720333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.54625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.419875 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.65125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.288625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.24025 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.253916 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.355917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.645584 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.191875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.1255 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.25725 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.299708 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.267541 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.258084 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.218959 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.349625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.644166 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.140292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.101917 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.221541 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.301208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.625709 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.705875 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.70525 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.488333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.4715 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.100125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.132625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.292958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.329042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.658125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.168167 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.749 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.526375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.47875 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.069042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.729 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.236333 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.317292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.3695 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.68325 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.291791 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.455417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.455709 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.028875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.739541 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.695834 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.245458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.352417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.615125 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.267208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.24475 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.223541 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.289833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.598334 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.133291 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.110167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.338375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.626625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.264958 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.243042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.255583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.328125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.712875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.178583 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.140791 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.283666 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.475917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.064625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.7305 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.72575 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.416 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.644541 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.137166 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.100041 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.24475 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.311417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.006292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.729417 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.708833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.402084 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.430792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.631458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.366709 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.257291 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.385875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.33475 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.707416 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.637792 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.432458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.417458 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.99 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.253625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.246417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.234583 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.326125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.635959 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.181917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.148083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.340334 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.379459 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.697792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.2605 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.327625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.387417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.632334 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.313625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.168792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.275792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.329292 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.592167 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.142667 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.6905 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.568541 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.438667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.036666 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.699417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.284083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.322875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.619709 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.151375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.116291 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.485792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.47525 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.059792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.733875 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.723417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.308458 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.361125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.618375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.25175 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.24475 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.42975 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.0385 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.774458 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.756958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.56625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.374334 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.636333 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.293708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.246041 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.315916 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.294209 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.643583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.127917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.111916 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.245417 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.032625 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 2.831833 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 386.42125 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 372.656792 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.0905 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 9.837041 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 409.035917 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 369.135042 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.120709 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 8.363292 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 403.163625 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 373.446708 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1019.223708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.73475 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.298333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.3185 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.400083 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.398708 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 759.180875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.740166 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.178875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.138958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.424875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.339 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 889.597709 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.103375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.72075 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.705541 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.642625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.547125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.714625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.209084 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.146708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.342542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.321958 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 758.321208 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.1245 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.762875 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.763333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.674291 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.46875 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 897.623791 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.772625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.32825 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.254417 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.321875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.410333 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1018.509792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.788541 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.717292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.526541 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.486792 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 897.484542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.125084 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.311625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.243208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.282042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.373875 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1016.398542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.682084 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.157042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.1215 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.311417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.337542 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 763.053083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.782625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.363333 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.391 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.661167 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.282584 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.241417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.272417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.315084 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.621541 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.138375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.107125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.505208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.425375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.029417 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.699 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.70375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.290625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.643042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.134125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.105292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.254167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.431333 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.031375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.785542 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.726333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.529792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.373459 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.681875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.286 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.246875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.245542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.022208 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.710375 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.728125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.529042 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.470542 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.677875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.305 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.312917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.370417 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.364708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.6325 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.162625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.122541 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.248291 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.348666 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.295458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.263667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.291291 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.365083 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.659708 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.175 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.098166 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.241834 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.273291 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.657333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.737167 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.700416 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.572292 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.472792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.079917 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.136833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.280834 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.3585 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.656292 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.145458 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.692958 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.430417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.422792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.0365 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.741 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.265917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.316416 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.3955 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.689458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.286583 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.548917 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.4805 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.094833 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.728708 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.712667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.292875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.346708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.642458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.269167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.229542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.258708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.297959 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.62325 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.12525 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.169666 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.390792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.636542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.318 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.272041 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.289459 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.333125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.675208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.169458 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.14175 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.252875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.49075 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.047292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.696833 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.738833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.485584 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.663375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.157583 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.147041 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.339333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.351583 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.055958 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.725584 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.743 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.503333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.4385 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.655542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.303833 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.271791 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.358916 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.384833 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.761208 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.737667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.5115 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.435792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.085625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.327208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.267459 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.293208 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.364333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.690667 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.165125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.131417 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.28675 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.331625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.657291 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.247042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.259834 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.333541 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.60425 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.262292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.100834 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.273083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.353208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.634708 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.161958 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.736375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.5685 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.477167 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.029333 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.745542 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.307583 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.290792 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.707583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.15625 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.125417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.525667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.455083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.068709 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.716 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.688541 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.267208 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.358 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.686875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.318708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.282875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.482958 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.065708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.756666 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.753917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.640042 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.397333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.6415 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.279333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.245208 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.333958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.290042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.683083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.173542 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.133833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.319667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.68375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.301917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.261375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.262792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.35575 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.647084 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.167375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.1415 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.298625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.300542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.031166 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.733333 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.702083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.469416 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.436875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.134958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.1135 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.245417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.288791 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.646042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.727583 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.720833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.525666 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.464166 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.052042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.279375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.229625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.302416 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.33625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.621209 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.712458 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.489708 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.452667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.046625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.732416 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.279833 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.322584 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.399458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.638416 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.270667 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.119458 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.275666 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.309 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.652625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.161916 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.272959 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.360667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.625708 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.282875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.236583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.268958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.288875 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.642 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.131416 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.102459 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.505875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.436917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.049875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.743375 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.731 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.326916 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.683833 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.155125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.126292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.348792 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.448167 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.028166 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.724959 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.710917 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.525542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.373084 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.648375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.318208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.288209 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.332667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.067708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.772125 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.740125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.521292 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.456583 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.671542 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.289333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.261709 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.34125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.360583 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.625708 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.158666 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.129833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.283042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.3265 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.296375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.260541 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.279833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.356208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.64875 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.16075 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.127083 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.311417 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.3625 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.696709 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.717875 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.7045 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.475875 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.471667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.051 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.164084 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.246042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.304667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.585416 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.143917 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.652583 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.552833 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.464333 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.042 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.709875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.282042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.306875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.352375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.63775 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.278459 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.530333 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.430917 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.046167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.732375 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.758459 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.324292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.385209 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.628833 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.277917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.283875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.317958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.304 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.667583 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.134667 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.1165 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.32675 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.628042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.286042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.236042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.230166 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.308083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.611541 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.133708 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.109125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.252 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.438 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.043084 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.752292 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.730083 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.457375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.635 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.142791 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.13425 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.321584 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.282667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 1.057875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.735125 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.726541 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.619583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.467709 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.648583 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.28725 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.262125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.28175 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.374083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.74925 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.725667 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.505834 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.482417 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.059292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.301334 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.249917 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.269667 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.345583 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.615125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.135 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.134167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.312875 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.3035 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.626167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.308084 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.272625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.3755 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.666292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.281791 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.122709 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.261125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.29075 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.641125 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.125875 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.699125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.479917 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.434084 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.023291 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.6985 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.3135 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.318542 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.676 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.181916 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.121792 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.492833 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.43825 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.066166 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.7565 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.727083 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.359709 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.35425 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.629458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.271958 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.236542 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.446833 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.030541 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.735542 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.707333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.459209 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.377458 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.687208 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.311583 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.307916 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.360708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.299167 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.63825 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.147083 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.13075 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.294167 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.033208 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 2.836792 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 387.713084 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 374.223833 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.080542 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 5.119291 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 408.29225 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 366.260167 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.2625 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 8.492541 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 418.215208 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 362.665459 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + }, + { + "samples": [ + { + "workload": "affine", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 1027.877792 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.691833 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.3655 + }, + { + "workload": "affine", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.2205 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.268708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.3785 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 765.552917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 0.69425 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.179333 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.126667 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.276166 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.303 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 0, + "position": 0, + "ms": 906.57425 + }, + { + "workload": "where", + "backend": "tcc", + "round": 0, + "position": 1, + "ms": 1.145 + }, + { + "workload": "where", + "backend": "gcc", + "round": 0, + "position": 2, + "ms": 0.79725 + }, + { + "workload": "where", + "backend": "clang", + "round": 0, + "position": 3, + "ms": 0.671166 + }, + { + "workload": "where", + "backend": "numpy", + "round": 0, + "position": 4, + "ms": 0.644791 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 0, + "position": 5, + "ms": 0.470208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.6425 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.165833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.130708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.344833 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.336125 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 779.413084 + }, + { + "workload": "where", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 1.097458 + }, + { + "workload": "where", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.731625 + }, + { + "workload": "where", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.72 + }, + { + "workload": "where", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.630917 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.532042 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 915.7215 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 1, + "position": 0, + "ms": 0.665833 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 1, + "position": 1, + "ms": 0.285458 + }, + { + "workload": "affine", + "backend": "clang", + "round": 1, + "position": 2, + "ms": 0.229375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 1, + "position": 3, + "ms": 0.274875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 1, + "position": 4, + "ms": 0.367792 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 1, + "position": 5, + "ms": 1027.926834 + }, + { + "workload": "where", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.799542 + }, + { + "workload": "where", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.742875 + }, + { + "workload": "where", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.587375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.508041 + }, + { + "workload": "where", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 905.519792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 1.094792 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.290333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.245625 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.306334 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.393334 + }, + { + "workload": "affine", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 1029.246667 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.691959 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 2, + "position": 0, + "ms": 0.181166 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 2, + "position": 1, + "ms": 0.135 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 2, + "position": 2, + "ms": 0.336625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 2, + "position": 3, + "ms": 0.319833 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "round": 2, + "position": 4, + "ms": 776.47325 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 2, + "position": 5, + "ms": 0.745 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.351667 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.382833 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.644666 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.272958 + }, + { + "workload": "affine", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.236709 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.254542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.356208 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 0.631584 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.153541 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.130875 + }, + { + "workload": "where", + "backend": "numpy", + "round": 3, + "position": 0, + "ms": 0.478625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 3, + "position": 1, + "ms": 0.430834 + }, + { + "workload": "where", + "backend": "tcc", + "round": 3, + "position": 2, + "ms": 1.114083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 3, + "position": 3, + "ms": 0.839083 + }, + { + "workload": "where", + "backend": "clang", + "round": 3, + "position": 4, + "ms": 0.699667 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.30525 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.609042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.159541 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.118958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.262625 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.430291 + }, + { + "workload": "where", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 1.005375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.714458 + }, + { + "workload": "where", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.688541 + }, + { + "workload": "where", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.556291 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 4, + "position": 0, + "ms": 0.381042 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 4, + "position": 1, + "ms": 0.661292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 4, + "position": 2, + "ms": 0.337708 + }, + { + "workload": "affine", + "backend": "clang", + "round": 4, + "position": 3, + "ms": 0.266291 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 4, + "position": 4, + "ms": 0.328292 + }, + { + "workload": "where", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 1.080667 + }, + { + "workload": "where", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.75475 + }, + { + "workload": "where", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.675625 + }, + { + "workload": "where", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.547167 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.421958 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.639292 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.313167 + }, + { + "workload": "affine", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.25475 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.343292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.351833 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 5, + "position": 0, + "ms": 0.652333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 5, + "position": 1, + "ms": 0.151875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 5, + "position": 2, + "ms": 0.120125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 5, + "position": 3, + "ms": 0.279333 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 5, + "position": 4, + "ms": 0.29525 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.311291 + }, + { + "workload": "affine", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.246125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.329041 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.389333 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.664083 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.160916 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.135333 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.351375 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.309416 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 0.6325 + }, + { + "workload": "where", + "backend": "gcc", + "round": 6, + "position": 0, + "ms": 0.739792 + }, + { + "workload": "where", + "backend": "clang", + "round": 6, + "position": 1, + "ms": 0.714292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 6, + "position": 2, + "ms": 0.50425 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 6, + "position": 3, + "ms": 0.427709 + }, + { + "workload": "where", + "backend": "tcc", + "round": 6, + "position": 4, + "ms": 1.040542 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.112167 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.304209 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.288042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.631 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.136916 + }, + { + "workload": "where", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.721375 + }, + { + "workload": "where", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.519958 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.444792 + }, + { + "workload": "where", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 1.078541 + }, + { + "workload": "where", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.763125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 7, + "position": 0, + "ms": 0.29425 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 7, + "position": 1, + "ms": 0.410459 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 7, + "position": 2, + "ms": 0.392125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 7, + "position": 3, + "ms": 0.647875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 7, + "position": 4, + "ms": 0.276084 + }, + { + "workload": "where", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.491791 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.43275 + }, + { + "workload": "where", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 1.10375 + }, + { + "workload": "where", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.74725 + }, + { + "workload": "where", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.752459 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.366833 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.411708 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.617209 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.267084 + }, + { + "workload": "affine", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.250166 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 8, + "position": 0, + "ms": 0.283334 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 8, + "position": 1, + "ms": 0.301666 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 8, + "position": 2, + "ms": 0.672459 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 8, + "position": 3, + "ms": 0.150084 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 8, + "position": 4, + "ms": 0.102084 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.343167 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.616166 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.270791 + }, + { + "workload": "affine", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.244 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.258125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.281375 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 0.617625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.129584 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.101208 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.273833 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 9, + "position": 0, + "ms": 0.4185 + }, + { + "workload": "where", + "backend": "tcc", + "round": 9, + "position": 1, + "ms": 1.050083 + }, + { + "workload": "where", + "backend": "gcc", + "round": 9, + "position": 2, + "ms": 0.747084 + }, + { + "workload": "where", + "backend": "clang", + "round": 9, + "position": 3, + "ms": 0.721416 + }, + { + "workload": "where", + "backend": "numpy", + "round": 9, + "position": 4, + "ms": 0.578416 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.673 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.160958 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.140792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.30475 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.319459 + }, + { + "workload": "where", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 1.041542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.729 + }, + { + "workload": "where", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.727292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.533334 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.444041 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 10, + "position": 0, + "ms": 0.627625 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 10, + "position": 1, + "ms": 0.27975 + }, + { + "workload": "affine", + "backend": "clang", + "round": 10, + "position": 2, + "ms": 0.267667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 10, + "position": 3, + "ms": 0.305125 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 10, + "position": 4, + "ms": 0.391416 + }, + { + "workload": "where", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.740459 + }, + { + "workload": "where", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.707292 + }, + { + "workload": "where", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.457458 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.432291 + }, + { + "workload": "where", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 1.013209 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.267208 + }, + { + "workload": "affine", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.22925 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.26025 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.34475 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.619166 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 11, + "position": 0, + "ms": 0.134417 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 11, + "position": 1, + "ms": 0.106 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 11, + "position": 2, + "ms": 0.246708 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 11, + "position": 3, + "ms": 0.285708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 11, + "position": 4, + "ms": 0.615291 + }, + { + "workload": "affine", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.232959 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.284167 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.404666 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.645333 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.283125 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.120792 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.2545 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.308958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 0.617625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.163292 + }, + { + "workload": "where", + "backend": "clang", + "round": 12, + "position": 0, + "ms": 0.701417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 12, + "position": 1, + "ms": 0.463583 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 12, + "position": 2, + "ms": 0.431959 + }, + { + "workload": "where", + "backend": "tcc", + "round": 12, + "position": 3, + "ms": 1.01925 + }, + { + "workload": "where", + "backend": "gcc", + "round": 12, + "position": 4, + "ms": 0.738125 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.31525 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.292 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.594625 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.129666 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.106 + }, + { + "workload": "where", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.453417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.439375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 1.064167 + }, + { + "workload": "where", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.744 + }, + { + "workload": "where", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.707 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 13, + "position": 0, + "ms": 0.320834 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 13, + "position": 1, + "ms": 0.369917 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 13, + "position": 2, + "ms": 0.686916 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 13, + "position": 3, + "ms": 0.286625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 13, + "position": 4, + "ms": 0.25575 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.441542 + }, + { + "workload": "where", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 1.033 + }, + { + "workload": "where", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.71475 + }, + { + "workload": "where", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.697792 + }, + { + "workload": "where", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.444 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.37025 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.634875 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.286583 + }, + { + "workload": "affine", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.256209 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.325167 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 14, + "position": 0, + "ms": 0.305125 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 14, + "position": 1, + "ms": 0.665208 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 14, + "position": 2, + "ms": 0.14975 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 14, + "position": 3, + "ms": 0.13475 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 14, + "position": 4, + "ms": 0.271917 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.629375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.277084 + }, + { + "workload": "affine", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.241834 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.254 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.346708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 0.660166 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.128792 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.106625 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.267458 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.320708 + }, + { + "workload": "where", + "backend": "tcc", + "round": 15, + "position": 0, + "ms": 1.073708 + }, + { + "workload": "where", + "backend": "gcc", + "round": 15, + "position": 1, + "ms": 0.69775 + }, + { + "workload": "where", + "backend": "clang", + "round": 15, + "position": 2, + "ms": 0.723167 + }, + { + "workload": "where", + "backend": "numpy", + "round": 15, + "position": 3, + "ms": 0.575541 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 15, + "position": 4, + "ms": 0.49425 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.190875 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.136583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.336792 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.3105 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.62475 + }, + { + "workload": "where", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.707417 + }, + { + "workload": "where", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.71575 + }, + { + "workload": "where", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.437041 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.422709 + }, + { + "workload": "where", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 1.04925 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 16, + "position": 0, + "ms": 0.310125 + }, + { + "workload": "affine", + "backend": "clang", + "round": 16, + "position": 1, + "ms": 0.289792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 16, + "position": 2, + "ms": 0.395834 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 16, + "position": 3, + "ms": 0.383125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 16, + "position": 4, + "ms": 0.654084 + }, + { + "workload": "where", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.719333 + }, + { + "workload": "where", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.475459 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.482958 + }, + { + "workload": "where", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 1.022791 + }, + { + "workload": "where", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.728041 + }, + { + "workload": "affine", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.230584 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.272625 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.371625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.632458 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.283583 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 17, + "position": 0, + "ms": 0.130916 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 17, + "position": 1, + "ms": 0.299042 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 17, + "position": 2, + "ms": 0.303667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 17, + "position": 3, + "ms": 0.640792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 17, + "position": 4, + "ms": 0.151416 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.285209 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.368125 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.634 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.274333 + }, + { + "workload": "affine", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.234709 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.305083 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.320042 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 0.672541 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.154042 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.166125 + }, + { + "workload": "where", + "backend": "numpy", + "round": 18, + "position": 0, + "ms": 0.465459 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 18, + "position": 1, + "ms": 0.42825 + }, + { + "workload": "where", + "backend": "tcc", + "round": 18, + "position": 2, + "ms": 1.025542 + }, + { + "workload": "where", + "backend": "gcc", + "round": 18, + "position": 3, + "ms": 0.706792 + }, + { + "workload": "where", + "backend": "clang", + "round": 18, + "position": 4, + "ms": 0.739542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.286708 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.623375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.12975 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.1055 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.281208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.433667 + }, + { + "workload": "where", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 1.052209 + }, + { + "workload": "where", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.750458 + }, + { + "workload": "where", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.743042 + }, + { + "workload": "where", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.563542 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 19, + "position": 0, + "ms": 0.4095 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 19, + "position": 1, + "ms": 0.667042 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 19, + "position": 2, + "ms": 0.300792 + }, + { + "workload": "affine", + "backend": "clang", + "round": 19, + "position": 3, + "ms": 0.25525 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 19, + "position": 4, + "ms": 0.316 + }, + { + "workload": "where", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 1.036917 + }, + { + "workload": "where", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.7205 + }, + { + "workload": "where", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.697916 + }, + { + "workload": "where", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.42575 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.434417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.648916 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.272583 + }, + { + "workload": "affine", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.265375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.286708 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.374667 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 20, + "position": 0, + "ms": 0.6735 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 20, + "position": 1, + "ms": 0.15325 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 20, + "position": 2, + "ms": 0.185958 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 20, + "position": 3, + "ms": 0.312084 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 20, + "position": 4, + "ms": 0.294833 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.2745 + }, + { + "workload": "affine", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.242042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.274917 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.35625 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.629 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.13 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.107875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.251125 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.324291 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 0.641875 + }, + { + "workload": "where", + "backend": "gcc", + "round": 21, + "position": 0, + "ms": 0.710916 + }, + { + "workload": "where", + "backend": "clang", + "round": 21, + "position": 1, + "ms": 0.719417 + }, + { + "workload": "where", + "backend": "numpy", + "round": 21, + "position": 2, + "ms": 0.522666 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 21, + "position": 3, + "ms": 0.465458 + }, + { + "workload": "where", + "backend": "tcc", + "round": 21, + "position": 4, + "ms": 1.050916 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.130583 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.335958 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.313417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.648375 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.153208 + }, + { + "workload": "where", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.717875 + }, + { + "workload": "where", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.444375 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.445083 + }, + { + "workload": "where", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 1.079792 + }, + { + "workload": "where", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.732375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 22, + "position": 0, + "ms": 0.248667 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 22, + "position": 1, + "ms": 0.302166 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 22, + "position": 2, + "ms": 0.347459 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 22, + "position": 3, + "ms": 0.631667 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 22, + "position": 4, + "ms": 0.288583 + }, + { + "workload": "where", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.485 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.447041 + }, + { + "workload": "where", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 1.078625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.733542 + }, + { + "workload": "where", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.711125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.301375 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.35075 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.625083 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.284291 + }, + { + "workload": "affine", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.259 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 23, + "position": 0, + "ms": 0.271416 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 23, + "position": 1, + "ms": 0.289 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 23, + "position": 2, + "ms": 0.626791 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 23, + "position": 3, + "ms": 0.130292 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 23, + "position": 4, + "ms": 0.111875 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.340291 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.683791 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.299625 + }, + { + "workload": "affine", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.258792 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.3115 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.329917 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 0.695042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.163833 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.140708 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.303125 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 24, + "position": 0, + "ms": 0.445167 + }, + { + "workload": "where", + "backend": "tcc", + "round": 24, + "position": 1, + "ms": 1.043917 + }, + { + "workload": "where", + "backend": "gcc", + "round": 24, + "position": 2, + "ms": 0.7145 + }, + { + "workload": "where", + "backend": "clang", + "round": 24, + "position": 3, + "ms": 0.699833 + }, + { + "workload": "where", + "backend": "numpy", + "round": 24, + "position": 4, + "ms": 0.44525 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.644459 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.131334 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.110833 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.317625 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.381042 + }, + { + "workload": "where", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.986666 + }, + { + "workload": "where", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.692208 + }, + { + "workload": "where", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.700416 + }, + { + "workload": "where", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.619417 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.453375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 25, + "position": 0, + "ms": 0.636708 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 25, + "position": 1, + "ms": 0.275042 + }, + { + "workload": "affine", + "backend": "clang", + "round": 25, + "position": 2, + "ms": 0.229875 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 25, + "position": 3, + "ms": 0.251291 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 25, + "position": 4, + "ms": 0.350625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.742958 + }, + { + "workload": "where", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.68775 + }, + { + "workload": "where", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.524208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.42375 + }, + { + "workload": "where", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 1.065375 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.2875 + }, + { + "workload": "affine", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.248916 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.276958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.359417 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.61025 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 26, + "position": 0, + "ms": 0.130375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 26, + "position": 1, + "ms": 0.106875 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 26, + "position": 2, + "ms": 0.260542 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 26, + "position": 3, + "ms": 0.299083 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 26, + "position": 4, + "ms": 0.592791 + }, + { + "workload": "affine", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.226125 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.247792 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.354208 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.622917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.257709 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.106292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.236291 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.311041 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 0.591042 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.154708 + }, + { + "workload": "where", + "backend": "clang", + "round": 27, + "position": 0, + "ms": 0.689334 + }, + { + "workload": "where", + "backend": "numpy", + "round": 27, + "position": 1, + "ms": 0.427667 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 27, + "position": 2, + "ms": 0.420125 + }, + { + "workload": "where", + "backend": "tcc", + "round": 27, + "position": 3, + "ms": 1.08475 + }, + { + "workload": "where", + "backend": "gcc", + "round": 27, + "position": 4, + "ms": 0.712291 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.286291 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.299417 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.671333 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.178167 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.132916 + }, + { + "workload": "where", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.514208 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.461625 + }, + { + "workload": "where", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 1.050625 + }, + { + "workload": "where", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.7225 + }, + { + "workload": "where", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.714375 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 28, + "position": 0, + "ms": 0.326958 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 28, + "position": 1, + "ms": 0.381709 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 28, + "position": 2, + "ms": 0.643459 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 28, + "position": 3, + "ms": 0.290917 + }, + { + "workload": "affine", + "backend": "clang", + "round": 28, + "position": 4, + "ms": 0.2485 + }, + { + "workload": "where", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.450791 + }, + { + "workload": "where", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 1.040292 + }, + { + "workload": "where", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.73125 + }, + { + "workload": "where", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.765916 + }, + { + "workload": "where", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.504292 + }, + { + "workload": "affine", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.41375 + }, + { + "workload": "affine", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.621917 + }, + { + "workload": "affine", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.269375 + }, + { + "workload": "affine", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.225042 + }, + { + "workload": "affine", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.262291 + }, + { + "workload": "polynomial", + "backend": "numexpr", + "round": 29, + "position": 0, + "ms": 0.289834 + }, + { + "workload": "polynomial", + "backend": "tcc", + "round": 29, + "position": 1, + "ms": 0.672792 + }, + { + "workload": "polynomial", + "backend": "gcc", + "round": 29, + "position": 2, + "ms": 0.127375 + }, + { + "workload": "polynomial", + "backend": "clang", + "round": 29, + "position": 3, + "ms": 0.107292 + }, + { + "workload": "polynomial", + "backend": "numpy", + "round": 29, + "position": 4, + "ms": 0.266875 + } + ], + "compile_rows": [ + { + "workload": "affine", + "backend": "interpreter", + "compile_ms": 0.037583 + }, + { + "workload": "affine", + "backend": "tcc", + "compile_ms": 3.098375 + }, + { + "workload": "affine", + "backend": "gcc", + "compile_ms": 434.279042 + }, + { + "workload": "affine", + "backend": "clang", + "compile_ms": 326.969375 + }, + { + "workload": "polynomial", + "backend": "interpreter", + "compile_ms": 0.030958 + }, + { + "workload": "polynomial", + "backend": "tcc", + "compile_ms": 1.564542 + }, + { + "workload": "polynomial", + "backend": "gcc", + "compile_ms": 373.530042 + }, + { + "workload": "polynomial", + "backend": "clang", + "compile_ms": 329.229667 + }, + { + "workload": "where", + "backend": "interpreter", + "compile_ms": 0.039833 + }, + { + "workload": "where", + "backend": "tcc", + "compile_ms": 1.592 + }, + { + "workload": "where", + "backend": "gcc", + "compile_ms": 371.308208 + }, + { + "workload": "where", + "backend": "clang", + "compile_ms": 327.319583 + } + ], + "compilers": { + "gcc": "/opt/homebrew/bin/gcc-16", + "clang": "/usr/bin/clang" + }, + "extension_sha256": "07b070f5002578fba410c213b803980b66e7156166087bb6b661d5c9c863cee3" + } + ], + "limitations": [ + "No core affinity or frequency tracing; not proof of the prior timing cause.", + "Finite C-contiguous workloads; compilation excluded from warm timings.", + "Interpreter has a smaller sample budget and participates in initial rounds only." + ] +} diff --git a/plans/menudet-jit-signoff.md b/plans/menudet-jit-signoff.md new file mode 100644 index 000000000..89ddec98b --- /dev/null +++ b/plans/menudet-jit-signoff.md @@ -0,0 +1,105 @@ +# Menudet portable host JIT — first slice + +This records the original slice and its historical measurements. The expanded +locals/branches/integer/unary-math boundary and new coverage benchmarks are recorded +in `menudet-jit-expanded-lowering.md`; current API coverage is documented in +`doc/reference/portable_dsl.rst`. + +## Implemented boundary + +- Explicit 1.1 `jit=True` / `ME_JIT_ON`; checked 1.0 and default routes unchanged. +- Typed-tree float32/float64 `+`, `-`, `*`, `/`, comparisons, Boolean short-circuit + selection and lazy `where`; final float/Boolean conversions preserve inferred + intermediate precision. Unsupported trees/signatures remain native interpreted. +- TCC and GCC use existing runtime/compiler/cache infrastructure. Private mask and + comparison bridge ABI; semantic profile and lowering revision enter cache identity. +- Per-call fenv/status handling and participating masks; constant operations cannot + silently fold away observable exceptions. WASM host-pointer lowering is disabled. +- Logical arrays retain bounded gathers, broadcasting and serial M5 reductions. + Unmasked all-direct tiles skip unnecessary per-lane coordinate/gather work. +- Native-required LazyExpr execution can explicitly request JIT. Its bounded + compiled-plan cache is artifact/configuration keyed and never caches values. + +Tests uncovered speculative float32 widening of an inactive scalar-union member +in the interpreter: finite float64 low bits could spuriously raise invalid. +A non-inlined widening helper prevents this, with a targeted bit-pattern regression. +Comparisons retain a host bridge (ordinary finite/infinite operands fast-path; +NaN operands use the exact typed evaluator path). This is not a fully inlined +comparison implementation and remains an optimization opportunity. + +## Local qualification + +Host: macOS arm64 / Apple M4 Pro, NumPy 2.5.3, NumExpr 2.14.2, GCC 16 and bundled +TCC. The editable integration explicitly uses the sibling miniexpr checkout. +Dependency pins and packaging requirements are not changed. + +`tests/test_menudet_jit.py` requires actual compiled kernels for supported cases: +56 TCC/GCC tests cover random/edge values, finite result bits, status, lazy branches, +masked reductions, varied tiles, reversed layouts, mixed float signatures, +constant-operation flags, concurrency, recovery and graph cache/mutation behavior. +Native `tests/numpy-compat/portable-jit.c` also checks standalone lazy/masked execution. +The authoritative corpus runner now reports actual compilation instead of rejecting +every compiled artifact as an impossible state. + +Local validation: full Python suite **12,759 passed / 55 skipped**; full native +suite **427 passed**; **11** ASan/UBSan corpus/array checks passed, plus forced +GCC-JIT standalone sanitizer execution. The latter found a NaN bridge overread +from copying `sizeof(me_expr)` out of header-only leaf allocations; copying only +through `offsetof(me_expr, parameters)` fixes it. The post-fix TCC/GCC focused +suite again passes all 56 tests. Authoritative request-on corpus runs execute +181 arithmetic and 15 function cases through compiled kernels, while other cases +retain their explicit diagnostic/native-contract/interpreter classifications. +GCC request-on corpus checks pass separately. The arithmetic corpus timeout was +increased from 60 to 300 seconds to include cold external compilation of hundreds +of kernels; numerical and diagnostic assertions are unchanged. + +Cross-platform CI, full native SIMD qualification, libm/integer/statement lowering +and release-wheel qualification remain pending. Existing CI failures from the prior +M1–M6 work are not represented as resolved by local host qualification. + +## Benchmark method + +`tools/menudet_jit_bench.py` produces `plans/menudet-jit-benchmarks.json`: 84 isolated +rows, sizes 8 and 262,144, float32/64, affine/polynomial/lazy-where workloads; +interpreter/TCC/GCC/NumPy/one-thread NumExpr. Every result is value-checked. +Compiled routes assert `has_jit`; each worker has a fresh cache directory. +Artifact import/compile, first execution and warm execution are recorded separately. +Warm medians use nine calls (three interpreter calls). Flat descriptor and logical +array timings are separate; these are finite C-contiguous workloads, not claims +about compressed traversal, production concurrency or universal NumPy performance. + +Reproduce in the `blosc2` conda environment with `MENUDET_WORK_DIR` pointing to the +approved OpenCode temporary directory and `python -m tools.menudet_jit_bench +--report plans/menudet-jit-benchmarks.json`. + +### Warm results (milliseconds, 262,144 float64 elements, flat API) + +**Follow-up:** `plans/menudet-jit-assembly-inspection.md` records actual kernel +disassembly and interleaved repeated-process timings. Those controlled where +measurements reverse the isolated table's TCC/GCC ranking (GCC/Clang about +0.72–0.74 ms versus TCC about 1.05 ms). Treat this table as recorded isolated-run +evidence, not a stable compiler ranking. +The subsequent full-table rerun in `plans/menudet-jit-interleaved.json` also finds +GCC/Clang outperform TCC on affine/polynomial; Clang polynomial measures 0.127 ms +versus NumPy 0.285 ms and one-thread NumExpr 0.308 ms. See the inspection report's +full-table section for the preferred warm compiler comparison. + +| Workload | Interpreter | TCC | GCC 16 | NumPy | NumExpr (1 thread) | +|---|---:|---:|---:|---:|---:| +| `x * 2 + y / 3 - 1` | 1059.037 | 0.645 | 0.878 | 0.305 | 0.353 | +| `(x + y) * (x - y)` | 794.278 | 0.643 | 0.182 | 0.256 | 0.318 | +| `where(x > 0, y / x, x * 2 + y)` | 936.570 | 1.035 | 2.226 | 0.507 | 0.469 | + +Across the six large flat workloads, actual JIT is approximately **420–4400×** +faster than the portable interpreter. The huge factor reflects interpreter overhead, +not superiority over mature array engines. Most rows still lose to NumPy/NumExpr; +the float64 polynomial GCC row is about 1.4× faster than NumPy and 1.75× than +one-thread NumExpr. Isolated medians show compiler/backend and tile-size variability, +so this is a measured example rather than a broad speedup claim. + +Fresh artifact import/compile costs **2.7–2.9 ms TCC** versus **372–404 ms GCC** +on this host. TCC is the better interactive default for this first slice; GCC's +warm benefit is workload-dependent. Logical-array timings and tiny-input overhead +are preserved in the JSON, not merged with flat execution results. Next obvious +targets are eliminating comparison bridge calls and improving GCC loop generation +without weakening lazy participation, per-node precision or diagnostic contracts. diff --git a/plans/menudet-m1-backend-baselines.json b/plans/menudet-m1-backend-baselines.json new file mode 100644 index 000000000..a934a02f1 --- /dev/null +++ b/plans/menudet-m1-backend-baselines.json @@ -0,0 +1,2417 @@ +{ + "schema_version": "menudet-backend-baseline-1", + "numpy": "2.5.3", + "platform": "macOS-26.6.2-arm64-arm-64bit-Mach-O", + "native_revision": "4e45081889e20e6a3820822a808f92de00fff7e6+M1-M2-harness", + "installed_native_revision": "3418cdce4b5c11e1661c8b6453e3d31d94b0b2b4", + "native_runner_sha256": "61701fa3829cf07ef89d1dea6f8fd7d3e3331e0bae2a75bddf8a14ea381c1a21", + "gcc": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0", + "trials": 3, + "repeats": 3, + "owned_cache_directory": "/private/var/folders/tb/7hwq2y354bb_68xwxjwjwwlr0000gn/T/opencode/m1-baseline-7d0uouzn", + "order": "alternating forward/reverse subprocess order", + "results": [ + { + "requested": "portable", + "backend": "interpreter", + "dtype": "float32", + "nitems": 16, + "compile_ns": 76000, + "same_process_recompile_ns": 0, + "first_ns": 34000, + "warm_median_ns": 31719, + "trial": 0, + "phase": "cold", + "process_ns": 755587708, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "float32", + "nitems": 16, + "compile_ns": 54000, + "same_process_recompile_ns": 15000, + "first_ns": 51000, + "warm_median_ns": 426, + "trial": 0, + "phase": "cold", + "process_ns": 4365333, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "float32", + "nitems": 16, + "compile_ns": 1997000, + "same_process_recompile_ns": 580000, + "first_ns": 5000, + "warm_median_ns": 90, + "trial": 0, + "phase": "cold", + "process_ns": 5508875, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "float32", + "nitems": 16, + "compile_ns": 71584, + "first_ns": 74625, + "warm_median_ns": 45417, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 192869750, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "float32", + "nitems": 16, + "compile_ns": 0, + "first_ns": 15750, + "warm_median_ns": 1084, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 167924375, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "float32", + "nitems": 16, + "compile_ns": 0, + "first_ns": 228083, + "warm_median_ns": 9542, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 159198833, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float32", + "nitems": 16, + "compile_ns": 821223000, + "same_process_recompile_ns": 320000, + "first_ns": 20000, + "warm_median_ns": 421, + "trial": 0, + "phase": "cold", + "process_ns": 827474959, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float32", + "nitems": 16, + "compile_ns": 1020000, + "same_process_recompile_ns": 104000, + "first_ns": 4000, + "warm_median_ns": 239, + "trial": 0, + "phase": "disk_cache_reuse", + "process_ns": 16090542, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 89000, + "same_process_recompile_ns": 0, + "first_ns": 496105000, + "warm_median_ns": 476109000, + "trial": 0, + "phase": "cold", + "process_ns": 1934285416, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 54000, + "same_process_recompile_ns": 15000, + "first_ns": 580000, + "warm_median_ns": 476000, + "trial": 0, + "phase": "cold", + "process_ns": 5263000, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 1049000, + "same_process_recompile_ns": 484000, + "first_ns": 469000, + "warm_median_ns": 397000, + "trial": 0, + "phase": "cold", + "process_ns": 5914917, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 71125, + "first_ns": 507698458, + "warm_median_ns": 470542542, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 2094906833, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 142458, + "warm_median_ns": 33333, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 160540708, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 476250, + "warm_median_ns": 231333, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 166598041, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 387090000, + "same_process_recompile_ns": 251000, + "first_ns": 385000, + "warm_median_ns": 118000, + "trial": 0, + "phase": "cold", + "process_ns": 393365750, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 638000, + "same_process_recompile_ns": 164000, + "first_ns": 145000, + "warm_median_ns": 45000, + "trial": 0, + "phase": "disk_cache_reuse", + "process_ns": 9178750, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "float64", + "nitems": 16, + "compile_ns": 61000, + "same_process_recompile_ns": 0, + "first_ns": 45000, + "warm_median_ns": 42731, + "trial": 0, + "phase": "cold", + "process_ns": 125770583, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "float64", + "nitems": 16, + "compile_ns": 51000, + "same_process_recompile_ns": 13000, + "first_ns": 9000, + "warm_median_ns": 410, + "trial": 0, + "phase": "cold", + "process_ns": 4079750, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "float64", + "nitems": 16, + "compile_ns": 1023000, + "same_process_recompile_ns": 524000, + "first_ns": 6000, + "warm_median_ns": 89, + "trial": 0, + "phase": "cold", + "process_ns": 4287667, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "float64", + "nitems": 16, + "compile_ns": 72542, + "first_ns": 78167, + "warm_median_ns": 52041, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 192253875, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "float64", + "nitems": 16, + "compile_ns": 0, + "first_ns": 14208, + "warm_median_ns": 1208, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 162787417, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "float64", + "nitems": 16, + "compile_ns": 0, + "first_ns": 234709, + "warm_median_ns": 9416, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 163681334, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float64", + "nitems": 16, + "compile_ns": 381073000, + "same_process_recompile_ns": 297000, + "first_ns": 17000, + "warm_median_ns": 290, + "trial": 0, + "phase": "cold", + "process_ns": 386571792, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float64", + "nitems": 16, + "compile_ns": 1304000, + "same_process_recompile_ns": 85000, + "first_ns": 6000, + "warm_median_ns": 173, + "trial": 0, + "phase": "disk_cache_reuse", + "process_ns": 15604875, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 56000, + "same_process_recompile_ns": 0, + "first_ns": 498614000, + "warm_median_ns": 480794000, + "trial": 0, + "phase": "cold", + "process_ns": 1962890500, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 61000, + "same_process_recompile_ns": 19000, + "first_ns": 673000, + "warm_median_ns": 523000, + "trial": 0, + "phase": "cold", + "process_ns": 5486958, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 1080000, + "same_process_recompile_ns": 497000, + "first_ns": 509000, + "warm_median_ns": 392000, + "trial": 0, + "phase": "cold", + "process_ns": 6186250, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 76542, + "first_ns": 472765125, + "warm_median_ns": 472027209, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 2058621625, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 242750, + "warm_median_ns": 149042, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 163817250, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 488875, + "warm_median_ns": 228416, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 164383000, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 400314000, + "same_process_recompile_ns": 261000, + "first_ns": 737000, + "warm_median_ns": 242000, + "trial": 0, + "phase": "cold", + "process_ns": 408334875, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 1110000, + "same_process_recompile_ns": 117000, + "first_ns": 556000, + "warm_median_ns": 227000, + "trial": 0, + "phase": "disk_cache_reuse", + "process_ns": 14971750, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "int64", + "nitems": 16, + "compile_ns": 58000, + "same_process_recompile_ns": 0, + "first_ns": 58000, + "warm_median_ns": 31822, + "trial": 0, + "phase": "cold", + "process_ns": 115562875, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "int64", + "nitems": 16, + "compile_ns": 45000, + "same_process_recompile_ns": 14000, + "first_ns": 18000, + "warm_median_ns": 353, + "trial": 0, + "phase": "cold", + "process_ns": 3725667, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "int64", + "nitems": 16, + "compile_ns": 1022000, + "same_process_recompile_ns": 482000, + "first_ns": 4000, + "warm_median_ns": 76, + "trial": 0, + "phase": "cold", + "process_ns": 3939833, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "int64", + "nitems": 16, + "compile_ns": 64833, + "first_ns": 65292, + "warm_median_ns": 37042, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 157035584, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "int64", + "nitems": 16, + "compile_ns": 0, + "first_ns": 20125, + "warm_median_ns": 1083, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 160054000, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "int64", + "nitems": 16, + "compile_ns": 0, + "first_ns": 232125, + "warm_median_ns": 9459, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 159781875, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "int64", + "nitems": 16, + "compile_ns": 385526000, + "same_process_recompile_ns": 279000, + "first_ns": 23000, + "warm_median_ns": 396, + "trial": 0, + "phase": "cold", + "process_ns": 391466792, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "int64", + "nitems": 16, + "compile_ns": 1172000, + "same_process_recompile_ns": 132000, + "first_ns": 6000, + "warm_median_ns": 191, + "trial": 0, + "phase": "disk_cache_reuse", + "process_ns": 15909208, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 110000, + "same_process_recompile_ns": 0, + "first_ns": 553011000, + "warm_median_ns": 483347000, + "trial": 0, + "phase": "cold", + "process_ns": 2009906625, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 47000, + "same_process_recompile_ns": 14000, + "first_ns": 664000, + "warm_median_ns": 520000, + "trial": 0, + "phase": "cold", + "process_ns": 5398209, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 1046000, + "same_process_recompile_ns": 491000, + "first_ns": 420000, + "warm_median_ns": 284000, + "trial": 0, + "phase": "cold", + "process_ns": 5771083, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 66584, + "first_ns": 473454542, + "warm_median_ns": 474706375, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 2061507459, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 258583, + "warm_median_ns": 139792, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 163080375, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 541917, + "warm_median_ns": 229542, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 0, + "phase": "cold", + "process_ns": 167548583, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 396837000, + "same_process_recompile_ns": 213000, + "first_ns": 720000, + "warm_median_ns": 191000, + "trial": 0, + "phase": "cold", + "process_ns": 404012750, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 807000, + "same_process_recompile_ns": 104000, + "first_ns": 561000, + "warm_median_ns": 158000, + "trial": 0, + "phase": "disk_cache_reuse", + "process_ns": 15682417, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float32", + "nitems": 16, + "compile_ns": 401196000, + "same_process_recompile_ns": 293000, + "first_ns": 14000, + "warm_median_ns": 413, + "trial": 1, + "phase": "cold", + "process_ns": 410450167, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float32", + "nitems": 16, + "compile_ns": 1149000, + "same_process_recompile_ns": 142000, + "first_ns": 7000, + "warm_median_ns": 211, + "trial": 1, + "phase": "disk_cache_reuse", + "process_ns": 13957875, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "float32", + "nitems": 16, + "compile_ns": 0, + "first_ns": 238500, + "warm_median_ns": 9167, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 184403625, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "float32", + "nitems": 16, + "compile_ns": 0, + "first_ns": 14250, + "warm_median_ns": 1208, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 158976625, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "float32", + "nitems": 16, + "compile_ns": 76917, + "first_ns": 66083, + "warm_median_ns": 40959, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 159076417, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "float32", + "nitems": 16, + "compile_ns": 1052000, + "same_process_recompile_ns": 479000, + "first_ns": 6000, + "warm_median_ns": 78, + "trial": 1, + "phase": "cold", + "process_ns": 4847500, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "float32", + "nitems": 16, + "compile_ns": 36000, + "same_process_recompile_ns": 16000, + "first_ns": 8000, + "warm_median_ns": 364, + "trial": 1, + "phase": "cold", + "process_ns": 3577583, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "float32", + "nitems": 16, + "compile_ns": 39000, + "same_process_recompile_ns": 0, + "first_ns": 32000, + "warm_median_ns": 29625, + "trial": 1, + "phase": "cold", + "process_ns": 91263042, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 388515000, + "same_process_recompile_ns": 310000, + "first_ns": 354000, + "warm_median_ns": 117000, + "trial": 1, + "phase": "cold", + "process_ns": 395776500, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 895000, + "same_process_recompile_ns": 114000, + "first_ns": 262000, + "warm_median_ns": 77000, + "trial": 1, + "phase": "disk_cache_reuse", + "process_ns": 15363625, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 461834, + "warm_median_ns": 198667, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 186833083, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 190125, + "warm_median_ns": 34375, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 161706041, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 72209, + "first_ns": 475409250, + "warm_median_ns": 472825250, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 2056529042, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 1057000, + "same_process_recompile_ns": 484000, + "first_ns": 465000, + "warm_median_ns": 411000, + "trial": 1, + "phase": "cold", + "process_ns": 6734041, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 44000, + "same_process_recompile_ns": 13000, + "first_ns": 560000, + "warm_median_ns": 426000, + "trial": 1, + "phase": "cold", + "process_ns": 4892959, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 44000, + "same_process_recompile_ns": 0, + "first_ns": 518113000, + "warm_median_ns": 481114000, + "trial": 1, + "phase": "cold", + "process_ns": 1964524708, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float64", + "nitems": 16, + "compile_ns": 389434000, + "same_process_recompile_ns": 267000, + "first_ns": 14000, + "warm_median_ns": 400, + "trial": 1, + "phase": "cold", + "process_ns": 395251458, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float64", + "nitems": 16, + "compile_ns": 684000, + "same_process_recompile_ns": 107000, + "first_ns": 4000, + "warm_median_ns": 191, + "trial": 1, + "phase": "disk_cache_reuse", + "process_ns": 14203583, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "float64", + "nitems": 16, + "compile_ns": 0, + "first_ns": 230583, + "warm_median_ns": 9583, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 185298833, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "float64", + "nitems": 16, + "compile_ns": 0, + "first_ns": 16917, + "warm_median_ns": 1209, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 161969459, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "float64", + "nitems": 16, + "compile_ns": 79667, + "first_ns": 68750, + "warm_median_ns": 38875, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 162976125, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "float64", + "nitems": 16, + "compile_ns": 1035000, + "same_process_recompile_ns": 486000, + "first_ns": 7000, + "warm_median_ns": 82, + "trial": 1, + "phase": "cold", + "process_ns": 4954459, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "float64", + "nitems": 16, + "compile_ns": 42000, + "same_process_recompile_ns": 12000, + "first_ns": 8000, + "warm_median_ns": 368, + "trial": 1, + "phase": "cold", + "process_ns": 3917792, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "float64", + "nitems": 16, + "compile_ns": 50000, + "same_process_recompile_ns": 0, + "first_ns": 32000, + "warm_median_ns": 32173, + "trial": 1, + "phase": "cold", + "process_ns": 107381750, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 385501000, + "same_process_recompile_ns": 61000, + "first_ns": 148000, + "warm_median_ns": 31000, + "trial": 1, + "phase": "cold", + "process_ns": 389222125, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 281000, + "same_process_recompile_ns": 39000, + "first_ns": 170000, + "warm_median_ns": 59000, + "trial": 1, + "phase": "disk_cache_reuse", + "process_ns": 4983875, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 505333, + "warm_median_ns": 227833, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 171880458, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 236375, + "warm_median_ns": 124500, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 164525541, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 64375, + "first_ns": 515065125, + "warm_median_ns": 478024792, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 2113620375, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 1055000, + "same_process_recompile_ns": 479000, + "first_ns": 499000, + "warm_median_ns": 375000, + "trial": 1, + "phase": "cold", + "process_ns": 6422792, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 34000, + "same_process_recompile_ns": 14000, + "first_ns": 624000, + "warm_median_ns": 479000, + "trial": 1, + "phase": "cold", + "process_ns": 4910875, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 40000, + "same_process_recompile_ns": 0, + "first_ns": 484677000, + "warm_median_ns": 483171000, + "trial": 1, + "phase": "cold", + "process_ns": 1937616209, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "int64", + "nitems": 16, + "compile_ns": 394287000, + "same_process_recompile_ns": 278000, + "first_ns": 14000, + "warm_median_ns": 395, + "trial": 1, + "phase": "cold", + "process_ns": 400049375, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "int64", + "nitems": 16, + "compile_ns": 1053000, + "same_process_recompile_ns": 143000, + "first_ns": 5000, + "warm_median_ns": 209, + "trial": 1, + "phase": "disk_cache_reuse", + "process_ns": 15298167, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "int64", + "nitems": 16, + "compile_ns": 0, + "first_ns": 234250, + "warm_median_ns": 9292, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 184120459, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "int64", + "nitems": 16, + "compile_ns": 0, + "first_ns": 20750, + "warm_median_ns": 1208, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 158412292, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "int64", + "nitems": 16, + "compile_ns": 65792, + "first_ns": 67000, + "warm_median_ns": 36583, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 160135666, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "int64", + "nitems": 16, + "compile_ns": 1081000, + "same_process_recompile_ns": 491000, + "first_ns": 8000, + "warm_median_ns": 74, + "trial": 1, + "phase": "cold", + "process_ns": 4876750, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "int64", + "nitems": 16, + "compile_ns": 40000, + "same_process_recompile_ns": 13000, + "first_ns": 8000, + "warm_median_ns": 393, + "trial": 1, + "phase": "cold", + "process_ns": 3897375, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "int64", + "nitems": 16, + "compile_ns": 43000, + "same_process_recompile_ns": 0, + "first_ns": 33000, + "warm_median_ns": 29980, + "trial": 1, + "phase": "cold", + "process_ns": 92661667, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 383264000, + "same_process_recompile_ns": 245000, + "first_ns": 662000, + "warm_median_ns": 248000, + "trial": 1, + "phase": "cold", + "process_ns": 391193833, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 1043000, + "same_process_recompile_ns": 81000, + "first_ns": 393000, + "warm_median_ns": 154000, + "trial": 1, + "phase": "disk_cache_reuse", + "process_ns": 14908708, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 514917, + "warm_median_ns": 242541, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 184769042, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 272708, + "warm_median_ns": 175750, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 165656959, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 68375, + "first_ns": 485807584, + "warm_median_ns": 486093584, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 1, + "phase": "cold", + "process_ns": 2121866875, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 1048000, + "same_process_recompile_ns": 475000, + "first_ns": 422000, + "warm_median_ns": 285000, + "trial": 1, + "phase": "cold", + "process_ns": 6044958, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 38000, + "same_process_recompile_ns": 21000, + "first_ns": 631000, + "warm_median_ns": 506000, + "trial": 1, + "phase": "cold", + "process_ns": 5113250, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 48000, + "same_process_recompile_ns": 0, + "first_ns": 488089000, + "warm_median_ns": 488408000, + "trial": 1, + "phase": "cold", + "process_ns": 1952467125, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "float32", + "nitems": 16, + "compile_ns": 49000, + "same_process_recompile_ns": 0, + "first_ns": 33000, + "warm_median_ns": 29998, + "trial": 2, + "phase": "cold", + "process_ns": 93189459, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "float32", + "nitems": 16, + "compile_ns": 49000, + "same_process_recompile_ns": 13000, + "first_ns": 9000, + "warm_median_ns": 377, + "trial": 2, + "phase": "cold", + "process_ns": 4081833, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "float32", + "nitems": 16, + "compile_ns": 1019000, + "same_process_recompile_ns": 482000, + "first_ns": 4000, + "warm_median_ns": 76, + "trial": 2, + "phase": "cold", + "process_ns": 4109375, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "float32", + "nitems": 16, + "compile_ns": 63709, + "first_ns": 69541, + "warm_median_ns": 40750, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 163085458, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "float32", + "nitems": 16, + "compile_ns": 0, + "first_ns": 16833, + "warm_median_ns": 1167, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 162304875, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "float32", + "nitems": 16, + "compile_ns": 0, + "first_ns": 241625, + "warm_median_ns": 9333, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 162816334, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float32", + "nitems": 16, + "compile_ns": 381358000, + "same_process_recompile_ns": 301000, + "first_ns": 13000, + "warm_median_ns": 390, + "trial": 2, + "phase": "cold", + "process_ns": 387358875, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float32", + "nitems": 16, + "compile_ns": 887000, + "same_process_recompile_ns": 128000, + "first_ns": 7000, + "warm_median_ns": 189, + "trial": 2, + "phase": "disk_cache_reuse", + "process_ns": 14195333, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 114000, + "same_process_recompile_ns": 0, + "first_ns": 506114000, + "warm_median_ns": 486315000, + "trial": 2, + "phase": "cold", + "process_ns": 1977080500, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 50000, + "same_process_recompile_ns": 14000, + "first_ns": 523000, + "warm_median_ns": 462000, + "trial": 2, + "phase": "cold", + "process_ns": 4975167, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 1022000, + "same_process_recompile_ns": 495000, + "first_ns": 443000, + "warm_median_ns": 403000, + "trial": 2, + "phase": "cold", + "process_ns": 6045250, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 67625, + "first_ns": 480377125, + "warm_median_ns": 485229750, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 2127802625, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 143583, + "warm_median_ns": 34958, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 167836375, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 491292, + "warm_median_ns": 231166, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 167631709, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 388727000, + "same_process_recompile_ns": 268000, + "first_ns": 329000, + "warm_median_ns": 109000, + "trial": 2, + "phase": "cold", + "process_ns": 395180834, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float32", + "nitems": 262144, + "compile_ns": 961000, + "same_process_recompile_ns": 76000, + "first_ns": 165000, + "warm_median_ns": 65000, + "trial": 2, + "phase": "disk_cache_reuse", + "process_ns": 13574208, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "float64", + "nitems": 16, + "compile_ns": 95000, + "same_process_recompile_ns": 0, + "first_ns": 77000, + "warm_median_ns": 31929, + "trial": 2, + "phase": "cold", + "process_ns": 112653750, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "float64", + "nitems": 16, + "compile_ns": 46000, + "same_process_recompile_ns": 14000, + "first_ns": 8000, + "warm_median_ns": 359, + "trial": 2, + "phase": "cold", + "process_ns": 3961958, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "float64", + "nitems": 16, + "compile_ns": 1072000, + "same_process_recompile_ns": 503000, + "first_ns": 6000, + "warm_median_ns": 77, + "trial": 2, + "phase": "cold", + "process_ns": 4048958, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "float64", + "nitems": 16, + "compile_ns": 67417, + "first_ns": 68500, + "warm_median_ns": 36250, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 161483875, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "float64", + "nitems": 16, + "compile_ns": 0, + "first_ns": 16417, + "warm_median_ns": 1166, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 161523125, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "float64", + "nitems": 16, + "compile_ns": 0, + "first_ns": 241209, + "warm_median_ns": 9209, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 163456791, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float64", + "nitems": 16, + "compile_ns": 400017000, + "same_process_recompile_ns": 131000, + "first_ns": 16000, + "warm_median_ns": 159, + "trial": 2, + "phase": "cold", + "process_ns": 404364125, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float64", + "nitems": 16, + "compile_ns": 524000, + "same_process_recompile_ns": 77000, + "first_ns": 3000, + "warm_median_ns": 92, + "trial": 2, + "phase": "disk_cache_reuse", + "process_ns": 7643834, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 101000, + "same_process_recompile_ns": 0, + "first_ns": 506295000, + "warm_median_ns": 491517000, + "trial": 2, + "phase": "cold", + "process_ns": 1985325042, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 49000, + "same_process_recompile_ns": 14000, + "first_ns": 621000, + "warm_median_ns": 509000, + "trial": 2, + "phase": "cold", + "process_ns": 5231791, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 1046000, + "same_process_recompile_ns": 482000, + "first_ns": 540000, + "warm_median_ns": 421000, + "trial": 2, + "phase": "cold", + "process_ns": 6042000, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 87625, + "first_ns": 493448709, + "warm_median_ns": 495628750, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 2159298875, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 256417, + "warm_median_ns": 143166, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 179051583, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 513959, + "warm_median_ns": 260708, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 169463958, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 381721000, + "same_process_recompile_ns": 140000, + "first_ns": 516000, + "warm_median_ns": 175000, + "trial": 2, + "phase": "cold", + "process_ns": 388295041, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "float64", + "nitems": 262144, + "compile_ns": 831000, + "same_process_recompile_ns": 105000, + "first_ns": 560000, + "warm_median_ns": 229000, + "trial": 2, + "phase": "disk_cache_reuse", + "process_ns": 13855041, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "int64", + "nitems": 16, + "compile_ns": 59000, + "same_process_recompile_ns": 0, + "first_ns": 44000, + "warm_median_ns": 31905, + "trial": 2, + "phase": "cold", + "process_ns": 115470375, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "int64", + "nitems": 16, + "compile_ns": 43000, + "same_process_recompile_ns": 19000, + "first_ns": 8000, + "warm_median_ns": 386, + "trial": 2, + "phase": "cold", + "process_ns": 3695917, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "int64", + "nitems": 16, + "compile_ns": 1040000, + "same_process_recompile_ns": 471000, + "first_ns": 4000, + "warm_median_ns": 74, + "trial": 2, + "phase": "cold", + "process_ns": 4219625, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "int64", + "nitems": 16, + "compile_ns": 71583, + "first_ns": 70375, + "warm_median_ns": 36542, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 161779000, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "int64", + "nitems": 16, + "compile_ns": 0, + "first_ns": 20667, + "warm_median_ns": 1041, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 160796833, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "int64", + "nitems": 16, + "compile_ns": 0, + "first_ns": 230334, + "warm_median_ns": 11792, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 162489041, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "int64", + "nitems": 16, + "compile_ns": 383493000, + "same_process_recompile_ns": 270000, + "first_ns": 13000, + "warm_median_ns": 286, + "trial": 2, + "phase": "cold", + "process_ns": 389043084, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "int64", + "nitems": 16, + "compile_ns": 962000, + "same_process_recompile_ns": 106000, + "first_ns": 5000, + "warm_median_ns": 200, + "trial": 2, + "phase": "disk_cache_reuse", + "process_ns": 13590875, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "portable", + "backend": "interpreter", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 60000, + "same_process_recompile_ns": 0, + "first_ns": 515203000, + "warm_median_ns": 492968000, + "trial": 2, + "phase": "cold", + "process_ns": 1999607250, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "interpreter", + "backend": "interpreter", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 61000, + "same_process_recompile_ns": 15000, + "first_ns": 657000, + "warm_median_ns": 469000, + "trial": 2, + "phase": "cold", + "process_ns": 5272250, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "tcc", + "backend": "tcc", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 1037000, + "same_process_recompile_ns": 527000, + "first_ns": 403000, + "warm_median_ns": 279000, + "trial": 2, + "phase": "cold", + "process_ns": 5836500, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control" + }, + { + "requested": "integrated", + "backend": "interpreter", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 72084, + "first_ns": 493148167, + "warm_median_ns": 500860542, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 2169853500, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "menudet-draft-1.0-checked" + }, + { + "requested": "numpy", + "backend": "numpy", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 288625, + "warm_median_ns": 188750, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 198825417, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "numexpr", + "backend": "numexpr", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 0, + "first_ns": 503584, + "warm_median_ns": 241833, + "numexpr_threads": 12, + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "trial": 2, + "phase": "cold", + "process_ns": 174528375, + "compiler_invocations": 0, + "route": "python", + "semantic_contract": "control" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 381057000, + "same_process_recompile_ns": 186000, + "first_ns": 722000, + "warm_median_ns": 238000, + "trial": 2, + "phase": "cold", + "process_ns": 389019208, + "compiler_invocations": 1, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + }, + { + "requested": "cc", + "backend": "cc", + "dtype": "int64", + "nitems": 262144, + "compile_ns": 880000, + "same_process_recompile_ns": 106000, + "first_ns": 631000, + "warm_median_ns": 223000, + "trial": 2, + "phase": "disk_cache_reuse", + "process_ns": 16458792, + "compiler_invocations": 0, + "route": "direct_native", + "semantic_contract": "full-miniexpr-control", + "compiler": "gcc-14 (Homebrew GCC 14.4.0) 14.4.0" + } + ], + "skips": [ + { + "backend": "tcc", + "phase": "disk_cache_reuse", + "reason": "TCC compiles in memory; no persistent disk artifact cache" + } + ], + "limitations": "Single host, affine positive-domain kernel only; native output preallocated, Python output allocated; no RSS/scaling claim." +} diff --git a/plans/menudet-m1-m2-signoff.md b/plans/menudet-m1-m2-signoff.md new file mode 100644 index 000000000..b922e2d50 --- /dev/null +++ b/plans/menudet-m1-m2-signoff.md @@ -0,0 +1,93 @@ +# Menudet M1 sign-off and M2 completion + +2026-10-09. M1 specification/inventory/baseline and M2 conformance-harness +acceptance are complete for the verified **macOS arm64** host. This does not +claim NumPy arithmetic compatibility or cross-platform qualification. Runtime +arithmetic, artifact/language 1.0, dependency pins and default backends are unchanged. + +## M1 remaining sign-off items + +- Actual TCC and Homebrew **GCC 14.4.0**, not Apple's gcc/Clang alias, are verified + by compiled program handles. Fallback is rejected by the benchmark executable. +- Three subprocess trials, alternating backend order, cover float32/float64/int64, + 16 and 262,144 elements. Cold compile, first execution, warm median, + same-process recompile and fresh-process GCC disk reuse are distinct fields. + Tiny native warm calls are batched to avoid timer-resolution artifacts. +- Owned per-trial caches and a compiler-invocation wrapper verify one GCC compile + for cold runs and zero for disk reuse. TCC's in-memory route has no persistent + disk-cache claim. Same-process recompilation is timing evidence, not an + instrumented TCC cache-hit claim. +- Direct-native portable versus installed Python-integrated portable baselines + locate the dominant cost in the portable interpreter profile, not Python copying. +- Inventory review replaces broad function/layout uncertainty with bounded shared + evidence. Broad full-interpreter/full-JIT dtype parity remains deliberately + `unverified`; performance controls cannot resolve that claim. + +Median float64 large-array warm times (`menudet-m1-backend-baselines.json`): + +| Route | Time | +| --- | ---: | +| Direct portable interpreter | 483 ms | +| Python-integrated portable interpreter | 478 ms | +| Full-DSL interpreter control | 0.509 ms | +| Full-DSL TCC control | 0.392 ms | +| Full-DSL GCC control | 0.175 ms | +| NumPy | 0.143 ms | +| NumExpr, one thread | 0.228 ms | + +Large float64 cold compilation medians: TCC 1.06 ms; GCC 386 ms. GCC fresh-process +disk-load compilation is 0.28–1.11 ms with zero compiler invocations. These are +single-host affine positive-domain baselines, not release performance budgets. +Native output is preallocated; Python output allocation is included. No RSS, +thread-scaling, complex-domain or general semantic equivalence claim is made. + +## M2 delivered + +- Native-owned v2 schema/corpus and independent C/Python readers, preserving v1. +- **64 shared cases: 41 matching, 21 known divergences, 2 named capability skips**. + Both off/on requests agree in dtype, shape, diagnostics, comparisons and outcome. +- Lossless fixed-width transport, weak/typed/0-D scalar categories, physical layout + recipes, NaN payload cases, exact/bitwise/ULP/tolerance comparison policies. +- Separate reviewed divergence and observed baseline checks: new failures are not + silently converted into passing golden data. Reports identify every mismatch, + missing capability, and actual backend; portable acceleration eligibility is zero. +- Seeded PCG64 properties and deterministic lane/scalar minimization, with the + overflow failure promoted into a stable shared vector. +- Repeated results/diagnostics, floating-environment restoration, failure-to-success + recovery using the same compiled handle, and malformed-vector regression tests. +- Standalone `tests/numpy-compat/example.c` artifact/typed-buffer consumer. +- Independent **284-sample** finite mpmath certification retained and passing. + +Evidence: `menudet-m2-conformance.json`, `menudet-m2-properties.json`, +`menudet-m2-math-certification.json`; native format contract is documented in +`miniexpr/doc/numpy-compat-conformance.md`. Runner/extension hashes and revisions +are recorded; native numerical sources still match the established installed pin. + +## Reproduction + +Validation completed: **12,248 Python tests passed, 55 skipped**; **421 native +CTest tests passed** with TCC enabled. The 28 focused M2 tests also pass against +the ASan/UBSan runner, including malformed-vector probes; all four checkpoint/v2 +off/on sanitizer CTest checks pass. The v2 corpus validates against its JSON +Schema. Ruff formatting/lint and whitespace checks pass. Other platforms remain +unverified. + +From Python-Blosc2, select the paths explicitly (using your own checkout/build): + +```sh +conda run -n blosc2 python -m tools.menudet_conformance run "$CORPUS_V2" \ + --native-runner "$RUNNER" --work-dir "$OWNED_WORK_DIR" --report report.json +conda run -n blosc2 python -m tools.menudet_conformance properties "$CORPUS_V2" \ + --native-runner "$RUNNER" --work-dir "$OWNED_WORK_DIR" --report properties.json +MENUDET_NUMPY_CORPUS_V2="$CORPUS_V2" MENUDET_NUMPY_RUNNER="$RUNNER" \ + conda run -n blosc2 pytest tests/test_menudet_conformance.py +conda run -n blosc2 python scripts/certify_menudet_math.py +``` + +Generation requires NumPy 2.5.3 and explicit `generate --checkpoint "$CORPUS_V1"`. +Recording is a separate reviewed action; normal runs never rewrite corpus data. +JSON Schema validation is development tooling only, not a native runtime dependency. + +Next is M3's explicit version-transition prerequisite and fixed-width arithmetic +slice. Platform qualification and eligible portable acceleration stay visible as +future work rather than being disguised as passing interpreter tests. diff --git a/plans/menudet-m2-conformance.json b/plans/menudet-m2-conformance.json new file mode 100644 index 000000000..284f09fe8 --- /dev/null +++ b/plans/menudet-m2-conformance.json @@ -0,0 +1,5717 @@ +{ + "schema_version": "menudet-conformance-report-2", + "provenance": { + "python_revision": "cf6f25c1020c13864413e97b39e466c893b77a7b", + "runner_sha256": "0d80f9ba4d2cd7412f2b03e6c4a58fc262e9f47c4667bd809ff0e95b29b64066", + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py", + "generator_revision": "m2-1", + "local_changes": "M1/M2 test tooling, native runners, schemas, corpus, reports; numerical runtime unchanged" + }, + "reference_numpy": "2.5.3", + "installed_numpy": "2.5.3", + "reference_drift": [], + "eligible_jit_cases": 0, + "requests": { + "off": { + "native": [ + { + "id": "int8-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int16-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int32-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int64-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "uint8-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "uint16-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "uint32-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "uint64-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int64-exact-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "int8-multiply-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int8-negate-min", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int64-absolute-min", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "float32-weak-literal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "float32-typed-float64-capture", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "41700000100000004008000000000000" + } + }, + { + "id": "int8-typed-int64-capture", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 1, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000080" + } + }, + { + "id": "float32-zero-dimensional", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [], + "encoding": "raw-be-hex", + "hex": "4b800000" + } + }, + { + "id": "int8-float-literal", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int8-uint8-promote", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00fe0080" + } + }, + { + "id": "int64-uint64-promote", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int64-uint64-compare", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + } + }, + { + "id": "int64-uint64-compare-rounding", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "01" + } + }, + { + "id": "bool-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "dtype-shape-or-values" + ], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000020000000000000001" + } + }, + { + "id": "int64-true-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "c002aaaaaaaaaaab4002aaaaaaaaaaab" + } + }, + { + "id": "int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000002fffffffffffffffd" + } + }, + { + "id": "int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "fffffffffffffffffffffffffffffffe" + } + }, + { + "id": "int64-zero-divide", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int64-min-divide", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int8-large-shift", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "float64-cast-int", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001ffffffffffffffff0000000000000000" + } + }, + { + "id": "float64-cast-infinity", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int64-narrow-output", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "float32-cast-float", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff40000000000008000000000000000" + } + }, + { + "id": "float32-sin", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000080000000" + } + }, + { + "id": "float32-sin-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3dff55773ef577443f576aa43f68c7b73f7d4695" + } + }, + { + "id": "float32-cos-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3f7e00ab3f60a9403f0a5140bed51133be14fdf6" + } + }, + { + "id": "float32-log-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "c0051592bf317218000000003f31721840051592" + } + }, + { + "id": "float32-sqrt-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3eb504f33f3504f33f8000003fb504f3403504f3" + } + }, + { + "id": "float32-exp-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3f910b023fd3094c402df85440ec7326453a4f54" + } + }, + { + "id": "float32-identity-special", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000800000007f800000ff8000007fc0000000000001" + } + }, + { + "id": "float32-sqrt-domain", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "7fc0000080000000400000007f8000007fc00000" + } + }, + { + "id": "float32-nan-payload-identity", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "7fc01234ffc05678" + } + }, + { + "id": "float64-sin-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3fbfeaaeee86ee363fdeaee8744b05f03feaed548f090cee3fed18f6ead1b4463fefa8d2a028cf7b" + } + }, + { + "id": "float64-cos-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3fefc015527d5bd33fec1528065b7d503fe14a280fb5068cbfdaa22657537205bfc29fbebf632f94" + } + }, + { + "id": "float64-log-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "c000a2b23f3bab73bfe62e42fefa39ef00000000000000003fe62e42fefa39ef4000a2b23f3bab73" + } + }, + { + "id": "float64-sqrt-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3fd6a09e667f3bcd3fe6a09e667f3bcd3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd" + } + }, + { + "id": "float64-exp-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3ff2216045b6f5cd3ffa61298e1e069c4005bf0a8b145769401d8e64b8d4ddae40a749ea7d470c6e" + } + }, + { + "id": "float64-identity-special", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000080000000000000007ff0000000000000fff00000000000007ff80000000000000000000000000001" + } + }, + { + "id": "float64-sqrt-domain", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000800000000000000040000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "float64-nan-payload-identity", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000001234fff8000000005678" + } + }, + { + "id": "float64-exp-tolerance", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fd78b56362cef383ff00000000000004005bf0a8b145769" + } + }, + { + "id": "layout-fortran", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000" + } + }, + { + "id": "layout-negative-stride", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000" + } + }, + { + "id": "layout-stepped-big-endian", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000" + } + }, + { + "id": "layout-little-endian", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000" + } + }, + { + "id": "empty-elementwise", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2, + 0 + ], + "encoding": "raw-be-hex", + "hex": "" + } + }, + { + "id": "weak-scalar-out-of-range", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "diagnostic-future-artifact", + "status": -2, + "category": "unsupported_requirement", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "diagnostic-invalid-source", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "diagnostic-wrong-binding", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "failure-then-success-same-handle", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "block-sum-explicit-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [], + "encoding": "raw-be-hex", + "hex": "000000000000000f" + } + }, + { + "id": "capability-complex-skipped", + "outcome": "skipped", + "backend": "none", + "skip_reason": "unsupported required capability", + "skipped_capabilities": [ + "numpy-complex" + ] + }, + { + "id": "capability-broadcast-skipped", + "outcome": "skipped", + "backend": "none", + "skip_reason": "unsupported required capability", + "skipped_capabilities": [ + "array-broadcasting" + ] + }, + { + "id": "seed-1729-minimized-int8-overflow", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + } + ], + "python": [ + { + "id": "int8-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int16-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int32-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int64-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "uint8-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "uint16-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "uint32-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "uint64-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int64-exact-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int8-multiply-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int8-negate-min", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int64-absolute-min", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "float32-weak-literal", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-typed-float64-capture", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "41700000100000004008000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int8-typed-int64-capture", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000080" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-zero-dimensional", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [], + "encoding": "raw-be-hex", + "hex": "4b800000", + "classes": [ + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int8-float-literal", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int8-uint8-promote", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00fe0080" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int64-uint64-promote", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int64-uint64-compare", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int64-uint64-compare-rounding", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "01" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "bool-add", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000020000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "dtype" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int64-true-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "c002aaaaaaaaaaab4002aaaaaaaaaaab", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000002fffffffffffffffd" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "fffffffffffffffffffffffffffffffe" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int64-zero-divide", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int64-min-divide", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int8-large-shift", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "float64-cast-int", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001ffffffffffffffff0000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-cast-infinity", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int64-narrow-output", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "float32-cast-float", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff40000000000008000000000000000", + "classes": [ + "finite", + "negative_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-sin", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000080000000", + "classes": [ + "positive_zero", + "negative_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-sin-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3dff55773ef577443f576aa43f68c7b73f7d4695", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-cos-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3f7e00ab3f60a9403f0a5140bed51133be14fdf6", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-log-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "c0051592bf317218000000003f31721840051592", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-sqrt-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3eb504f33f3504f33f8000003fb504f3403504f3", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-exp-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3f910b023fd3094c402df85440ec7326453a4f54", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-identity-special", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000800000007f800000ff8000007fc0000000000001", + "classes": [ + "positive_zero", + "negative_zero", + "positive_inf", + "negative_inf", + "nan", + "subnormal" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-sqrt-domain", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "7fc0000080000000400000007f8000007fc00000", + "classes": [ + "nan", + "negative_zero", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-nan-payload-identity", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "7fc01234ffc05678", + "classes": [ + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-sin-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3fbfeaaeee86ee363fdeaee8744b05f03feaed548f090cee3fed18f6ead1b4463fefa8d2a028cf7b", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-cos-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3fefc015527d5bd33fec1528065b7d503fe14a280fb5068cbfdaa22657537205bfc29fbebf632f94", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-log-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "c000a2b23f3bab73bfe62e42fefa39ef00000000000000003fe62e42fefa39ef4000a2b23f3bab73", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-sqrt-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3fd6a09e667f3bcd3fe6a09e667f3bcd3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-exp-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3ff2216045b6f5cd3ffa61298e1e069c4005bf0a8b145769401d8e64b8d4ddae40a749ea7d470c6e", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-identity-special", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000080000000000000007ff0000000000000fff00000000000007ff80000000000000000000000000001", + "classes": [ + "positive_zero", + "negative_zero", + "positive_inf", + "negative_inf", + "nan", + "subnormal" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-sqrt-domain", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000800000000000000040000000000000007ff00000000000007ff8000000000000", + "classes": [ + "nan", + "negative_zero", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-nan-payload-identity", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000001234fff8000000005678", + "classes": [ + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-exp-tolerance", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fd78b56362cef383ff00000000000004005bf0a8b145769", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "layout-fortran", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000", + "classes": [ + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "layout-negative-stride", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000", + "classes": [ + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "layout-stepped-big-endian", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000", + "classes": [ + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "layout-little-endian", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000", + "classes": [ + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "empty-elementwise", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2, + 0 + ], + "encoding": "raw-be-hex", + "hex": "" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-scalar-out-of-range", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "diagnostic-future-artifact", + "status": -2, + "category": "unsupported_requirement", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "diagnostic-invalid-source", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "diagnostic-wrong-binding", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "failure-then-success-same-handle", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "block-sum-explicit-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [], + "encoding": "raw-be-hex", + "hex": "000000000000000f" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capability-complex-skipped", + "outcome": "skipped", + "backend": "none", + "skipped_capabilities": [ + "numpy-complex" + ], + "skip_reason": "Complex numerical semantics are explicitly outside the current native capability set" + }, + { + "id": "capability-broadcast-skipped", + "outcome": "skipped", + "backend": "none", + "skipped_capabilities": [ + "array-broadcasting" + ], + "skip_reason": "Native array broadcasting is milestone 5, not an implemented kernel capability" + }, + { + "id": "seed-1729-minimized-int8-overflow", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + } + ] + }, + "on": { + "native": [ + { + "id": "int8-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int16-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int32-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int64-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "uint8-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "uint16-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "uint32-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "uint64-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int64-exact-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "int8-multiply-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int8-negate-min", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int64-absolute-min", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "float32-weak-literal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "float32-typed-float64-capture", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "41700000100000004008000000000000" + } + }, + { + "id": "int8-typed-int64-capture", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 1, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000080" + } + }, + { + "id": "float32-zero-dimensional", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [], + "encoding": "raw-be-hex", + "hex": "4b800000" + } + }, + { + "id": "int8-float-literal", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int8-uint8-promote", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00fe0080" + } + }, + { + "id": "int64-uint64-promote", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int64-uint64-compare", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + } + }, + { + "id": "int64-uint64-compare-rounding", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "01" + } + }, + { + "id": "bool-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "dtype-shape-or-values" + ], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000020000000000000001" + } + }, + { + "id": "int64-true-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "c002aaaaaaaaaaab4002aaaaaaaaaaab" + } + }, + { + "id": "int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000002fffffffffffffffd" + } + }, + { + "id": "int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "fffffffffffffffffffffffffffffffe" + } + }, + { + "id": "int64-zero-divide", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int64-min-divide", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int8-large-shift", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "float64-cast-int", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001ffffffffffffffff0000000000000000" + } + }, + { + "id": "float64-cast-infinity", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "int64-narrow-output", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "float32-cast-float", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff40000000000008000000000000000" + } + }, + { + "id": "float32-sin", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000080000000" + } + }, + { + "id": "float32-sin-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3dff55773ef577443f576aa43f68c7b73f7d4695" + } + }, + { + "id": "float32-cos-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3f7e00ab3f60a9403f0a5140bed51133be14fdf6" + } + }, + { + "id": "float32-log-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "c0051592bf317218000000003f31721840051592" + } + }, + { + "id": "float32-sqrt-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3eb504f33f3504f33f8000003fb504f3403504f3" + } + }, + { + "id": "float32-exp-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3f910b023fd3094c402df85440ec7326453a4f54" + } + }, + { + "id": "float32-identity-special", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000800000007f800000ff8000007fc0000000000001" + } + }, + { + "id": "float32-sqrt-domain", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "7fc0000080000000400000007f8000007fc00000" + } + }, + { + "id": "float32-nan-payload-identity", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "7fc01234ffc05678" + } + }, + { + "id": "float64-sin-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3fbfeaaeee86ee363fdeaee8744b05f03feaed548f090cee3fed18f6ead1b4463fefa8d2a028cf7b" + } + }, + { + "id": "float64-cos-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3fefc015527d5bd33fec1528065b7d503fe14a280fb5068cbfdaa22657537205bfc29fbebf632f94" + } + }, + { + "id": "float64-log-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "c000a2b23f3bab73bfe62e42fefa39ef00000000000000003fe62e42fefa39ef4000a2b23f3bab73" + } + }, + { + "id": "float64-sqrt-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3fd6a09e667f3bcd3fe6a09e667f3bcd3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd" + } + }, + { + "id": "float64-exp-finite-ulp", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3ff2216045b6f5cd3ffa61298e1e069c4005bf0a8b145769401d8e64b8d4ddae40a749ea7d470c6e" + } + }, + { + "id": "float64-identity-special", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000080000000000000007ff0000000000000fff00000000000007ff80000000000000000000000000001" + } + }, + { + "id": "float64-sqrt-domain", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000800000000000000040000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "float64-nan-payload-identity", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000001234fff8000000005678" + } + }, + { + "id": "float64-exp-tolerance", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fd78b56362cef383ff00000000000004005bf0a8b145769" + } + }, + { + "id": "layout-fortran", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000" + } + }, + { + "id": "layout-negative-stride", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000" + } + }, + { + "id": "layout-stepped-big-endian", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000" + } + }, + { + "id": "layout-little-endian", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000" + } + }, + { + "id": "empty-elementwise", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2, + 0 + ], + "encoding": "raw-be-hex", + "hex": "" + } + }, + { + "id": "weak-scalar-out-of-range", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "diagnostic-future-artifact", + "status": -2, + "category": "unsupported_requirement", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "diagnostic-invalid-source", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "diagnostic-wrong-binding", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "failure-then-success-same-handle", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + }, + { + "id": "block-sum-explicit-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [], + "encoding": "raw-be-hex", + "hex": "000000000000000f" + } + }, + { + "id": "capability-complex-skipped", + "outcome": "skipped", + "backend": "none", + "skip_reason": "unsupported required capability", + "skipped_capabilities": [ + "numpy-complex" + ] + }, + { + "id": "capability-broadcast-skipped", + "outcome": "skipped", + "backend": "none", + "skip_reason": "unsupported required capability", + "skipped_capabilities": [ + "array-broadcasting" + ] + }, + { + "id": "seed-1729-minimized-int8-overflow", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": false, + "baseline_regression": false, + "outcome": "known_divergence", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [ + "diagnostic" + ] + } + ], + "python": [ + { + "id": "int8-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int16-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int32-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int64-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "uint8-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "uint16-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "uint32-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "uint64-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int64-exact-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int8-multiply-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int8-negate-min", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int64-absolute-min", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "float32-weak-literal", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-typed-float64-capture", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "41700000100000004008000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int8-typed-int64-capture", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000080" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-zero-dimensional", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [], + "encoding": "raw-be-hex", + "hex": "4b800000", + "classes": [ + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int8-float-literal", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int8-uint8-promote", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00fe0080" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int64-uint64-promote", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int64-uint64-compare", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int64-uint64-compare-rounding", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "01" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "bool-add", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000020000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "dtype" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int64-true-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "c002aaaaaaaaaaab4002aaaaaaaaaaab", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000002fffffffffffffffd" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "fffffffffffffffffffffffffffffffe" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "int64-zero-divide", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int64-min-divide", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int8-large-shift", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "float64-cast-int", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001ffffffffffffffff0000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-cast-infinity", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "int64-narrow-output", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "float32-cast-float", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff40000000000008000000000000000", + "classes": [ + "finite", + "negative_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-sin", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000080000000", + "classes": [ + "positive_zero", + "negative_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-sin-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3dff55773ef577443f576aa43f68c7b73f7d4695", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-cos-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3f7e00ab3f60a9403f0a5140bed51133be14fdf6", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-log-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "c0051592bf317218000000003f31721840051592", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-sqrt-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3eb504f33f3504f33f8000003fb504f3403504f3", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-exp-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3f910b023fd3094c402df85440ec7326453a4f54", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-identity-special", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000800000007f800000ff8000007fc0000000000001", + "classes": [ + "positive_zero", + "negative_zero", + "positive_inf", + "negative_inf", + "nan", + "subnormal" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-sqrt-domain", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "7fc0000080000000400000007f8000007fc00000", + "classes": [ + "nan", + "negative_zero", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float32-nan-payload-identity", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "7fc01234ffc05678", + "classes": [ + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-sin-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3fbfeaaeee86ee363fdeaee8744b05f03feaed548f090cee3fed18f6ead1b4463fefa8d2a028cf7b", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-cos-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3fefc015527d5bd33fec1528065b7d503fe14a280fb5068cbfdaa22657537205bfc29fbebf632f94", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-log-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "c000a2b23f3bab73bfe62e42fefa39ef00000000000000003fe62e42fefa39ef4000a2b23f3bab73", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-sqrt-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3fd6a09e667f3bcd3fe6a09e667f3bcd3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-exp-finite-ulp", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "3ff2216045b6f5cd3ffa61298e1e069c4005bf0a8b145769401d8e64b8d4ddae40a749ea7d470c6e", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-identity-special", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000080000000000000007ff0000000000000fff00000000000007ff80000000000000000000000000001", + "classes": [ + "positive_zero", + "negative_zero", + "positive_inf", + "negative_inf", + "nan", + "subnormal" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-sqrt-domain", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000800000000000000040000000000000007ff00000000000007ff8000000000000", + "classes": [ + "nan", + "negative_zero", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-nan-payload-identity", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000001234fff8000000005678", + "classes": [ + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float64-exp-tolerance", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fd78b56362cef383ff00000000000004005bf0a8b145769", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "layout-fortran", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000", + "classes": [ + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "layout-negative-stride", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000", + "classes": [ + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "layout-stepped-big-endian", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000", + "classes": [ + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "layout-little-endian", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2, + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000404000004080000040a00000", + "classes": [ + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "empty-elementwise", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2, + 0 + ], + "encoding": "raw-be-hex", + "hex": "" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-scalar-out-of-range", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "diagnostic-future-artifact", + "status": -2, + "category": "unsupported_requirement", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "diagnostic-invalid-source", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "diagnostic-wrong-binding", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "failure-then-success-same-handle", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + }, + { + "id": "block-sum-explicit-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [], + "encoding": "raw-be-hex", + "hex": "000000000000000f" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capability-complex-skipped", + "outcome": "skipped", + "backend": "none", + "skipped_capabilities": [ + "numpy-complex" + ], + "skip_reason": "Complex numerical semantics are explicitly outside the current native capability set" + }, + { + "id": "capability-broadcast-skipped", + "outcome": "skipped", + "backend": "none", + "skipped_capabilities": [ + "array-broadcasting" + ], + "skip_reason": "Native array broadcasting is milestone 5, not an implemented kernel capability" + }, + { + "id": "seed-1729-minimized-int8-overflow", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": false, + "mismatches": [ + "diagnostic" + ], + "baseline_regression": false, + "outcome": "known_divergence" + } + ] + } + } +} diff --git a/plans/menudet-m2-math-certification.json b/plans/menudet-m2-math-certification.json new file mode 100644 index 000000000..e70b07504 --- /dev/null +++ b/plans/menudet-m2-math-certification.json @@ -0,0 +1,90 @@ +{ + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py", + "version": "4.15.0.dev0", + "platform": "macOS-26.6.2-arm64-arm-64bit-Mach-O", + "reference": "mpmath 1.3.0, 100/200 decimal digits", + "samples": 284, + "max_observed_ulp": { + "acos/float32": 1.0, + "acos/float64": 1.0, + "acosh/float32": 0, + "acosh/float64": 0, + "asin/float32": 1.0, + "asin/float64": 0, + "asinh/float32": 0, + "asinh/float64": 1.0, + "atan/float32": 0, + "atan/float64": 1.0, + "atanh/float32": 0, + "atanh/float64": 0, + "cbrt/float32": 0, + "cbrt/float64": 0, + "cos/float32": 0, + "cos/float64": 0, + "cosh/float32": 0, + "cosh/float64": 0, + "cospi/float32": 0, + "cospi/float64": 0, + "erf/float32": 0, + "erf/float64": 0, + "erfc/float32": 0, + "erfc/float64": 2.0, + "exp/float32": 0, + "exp/float64": 0, + "exp10/float32": 0, + "exp10/float64": 0, + "exp2/float32": 0, + "exp2/float64": 0, + "expm1/float32": 0, + "expm1/float64": 0, + "lgamma/float32": 0, + "lgamma/float64": 3.0, + "log/float32": 0, + "log/float64": 0, + "log10/float32": 0, + "log10/float64": 0, + "log1p/float32": 0, + "log1p/float64": 0, + "log2/float32": 0, + "log2/float64": 0, + "sin/float32": 0, + "sin/float64": 0, + "sinh/float32": 0, + "sinh/float64": 0, + "sinpi/float32": 1.0, + "sinpi/float64": 1.0, + "sqrt/float32": 0, + "sqrt/float64": 0, + "tan/float32": 0, + "tan/float64": 1.0, + "tanh/float32": 0, + "tanh/float64": 0, + "tgamma/float32": 0, + "tgamma/float64": 0, + "atan2/float32": 0, + "atan2/float64": 0, + "hypot/float32": 0, + "hypot/float64": 0, + "logaddexp/float32": 0, + "logaddexp/float64": 0, + "pow/float32": 0, + "pow/float64": 0, + "fdim/float32": 0, + "fdim/float64": 0, + "fmin/float32": 0, + "fmin/float64": 0, + "fmax/float32": 0, + "fmax/float64": 0, + "copysign/float32": 0, + "copysign/float64": 0, + "fmod/float32": 0, + "fmod/float64": 0, + "remainder/float32": 0, + "remainder/float64": 0, + "ldexp/float32": 0, + "ldexp/float64": 0, + "fma/float32": 0, + "fma/float64": 0 + }, + "failures": [] +} diff --git a/plans/menudet-m2-properties.json b/plans/menudet-m2-properties.json new file mode 100644 index 000000000..ced64f62f --- /dev/null +++ b/plans/menudet-m2-properties.json @@ -0,0 +1,159 @@ +{ + "rng": "PCG64", + "seeds": [ + 1729, + 20261009 + ], + "results": [ + { + "seed": 1729, + "cases": 49, + "matching": 48, + "known_divergences": 1, + "minimized": { + "id": "property-1729-boundary", + "operation": "add", + "semantic_revision": "menudet-draft-1.0-checked", + "requires": [ + "numeric" + ], + "artifact": "{\"constants\": [], \"context\": {\"ndim\": 0}, \"entry_point\": \"k\", \"inputs\": [{\"dtype\": \"int8\", \"name\": \"x\"}, {\"dtype\": \"int8\", \"name\": \"y\"}], \"language\": {\"name\": \"miniexpr\", \"version\": \"1.0\"}, \"metadata\": {}, \"output\": {\"contract\": \"elementwise\", \"dtype\": \"int8\"}, \"requires\": [\"numeric\"], \"schema_version\": \"1.0\", \"semantics\": {\"fp\": \"strict\"}, \"source\": \"def k(x, y):\\n return x + y\\n\"}", + "inputs": [ + { + "dtype": "int8", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "7f", + "name": "x", + "category": "array", + "layout": { + "order": "C", + "byteorder": "native", + "step": 1, + "reverse_axis": null + } + }, + { + "dtype": "int8", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "01", + "name": "y", + "category": "array", + "layout": { + "order": "C", + "byteorder": "native", + "step": 1, + "reverse_axis": null + } + } + ], + "scalar_operands": [], + "literal": null, + "comparison": { + "kind": "bitwise", + "atol": 0.0, + "rtol": 0.0, + "max_ulp": 0, + "nan": "bits", + "signed_zero": "exact" + }, + "reference_kind": "numpy", + "seed": 1729, + "expected": { + "dtype": "int8", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "80" + }, + "divergence": { + "id": "D01", + "reason": "Known checked-overflow boundary used to test minimization" + }, + "minimized_from": "property-1729-boundary" + }, + "promoted_case_id": "seed-1729-minimized-int8-overflow" + }, + { + "seed": 20261009, + "cases": 49, + "matching": 48, + "known_divergences": 1, + "minimized": { + "id": "property-20261009-boundary", + "operation": "add", + "semantic_revision": "menudet-draft-1.0-checked", + "requires": [ + "numeric" + ], + "artifact": "{\"constants\": [], \"context\": {\"ndim\": 0}, \"entry_point\": \"k\", \"inputs\": [{\"dtype\": \"int8\", \"name\": \"x\"}, {\"dtype\": \"int8\", \"name\": \"y\"}], \"language\": {\"name\": \"miniexpr\", \"version\": \"1.0\"}, \"metadata\": {}, \"output\": {\"contract\": \"elementwise\", \"dtype\": \"int8\"}, \"requires\": [\"numeric\"], \"schema_version\": \"1.0\", \"semantics\": {\"fp\": \"strict\"}, \"source\": \"def k(x, y):\\n return x + y\\n\"}", + "inputs": [ + { + "dtype": "int8", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "7f", + "name": "x", + "category": "array", + "layout": { + "order": "C", + "byteorder": "native", + "step": 1, + "reverse_axis": null + } + }, + { + "dtype": "int8", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "01", + "name": "y", + "category": "array", + "layout": { + "order": "C", + "byteorder": "native", + "step": 1, + "reverse_axis": null + } + } + ], + "scalar_operands": [], + "literal": null, + "comparison": { + "kind": "bitwise", + "atol": 0.0, + "rtol": 0.0, + "max_ulp": 0, + "nan": "bits", + "signed_zero": "exact" + }, + "reference_kind": "numpy", + "seed": 20261009, + "expected": { + "dtype": "int8", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "80" + }, + "divergence": { + "id": "D01", + "reason": "Known checked-overflow boundary used to test minimization" + }, + "minimized_from": "property-20261009-boundary" + }, + "promoted_case_id": null + } + ] +} diff --git a/plans/menudet-m3-conformance.json b/plans/menudet-m3-conformance.json new file mode 100644 index 000000000..6c08f6aef --- /dev/null +++ b/plans/menudet-m3-conformance.json @@ -0,0 +1,294155 @@ +{ + "schema_version": "menudet-conformance-report-2", + "provenance": { + "python_revision": "cf6f25c1020c13864413e97b39e466c893b77a7b", + "runner_sha256": "6461514510afe327c68fb7e1526ab4e802589ab530ee35366dc68eef0613609c", + "extension_sha256": "40669526c58a261753666a9cdf4520b8416f051e53b542e3435c444503a3cff0", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py", + "generator_revision": "m3-1", + "corpus_sha256": "f460350bd9d06b8d77272b10d87c5e83feca5f8f9258624e62e9280a3ee10abb", + "semantic_revisions": [ + "menudet-numpy-1.1" + ], + "local_changes": "M3 opt-in native 1.1 arithmetic, inference, casts, Python authoring and tests; checked 1.0 retained" + }, + "reference_numpy": "2.5.3", + "installed_numpy": "2.5.3", + "reference_drift": [], + "eligible_jit_cases": 0, + "requests": { + "off": { + "native": [ + { + "id": "promotion-bool-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "compare-bool-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-bool-subtract", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "mixed-bool-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "mixed-bool-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "mixed-bool-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "mixed-bool-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "compare-bool-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + } + }, + { + "id": "mixed-bool-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "mixed-bool-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "mixed-bool-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "mixed-bool-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "mixed-bool-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-bool-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-bool-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-bool-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-bool-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-bool-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-bool-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-bool-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-bool-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-bool-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-bool-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-bool-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-bool-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-bool-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-bool-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-bool-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-bool-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-bool-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-bool-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-bool-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-bool-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-bool-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-bool-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-bool-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-bool-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-bool-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-bool-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-bool-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-bool-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-bool-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-bool-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-bool-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-bool-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-bool-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "compare-bool-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + } + }, + { + "id": "mixed-bool-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "mixed-bool-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "mixed-bool-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "mixed-bool-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "mixed-bool-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-bool-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-bool-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-bool-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-bool-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-bool-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-bool-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-bool-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-bool-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-bool-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-bool-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-bool-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-bool-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-bool-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-bool-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-bool-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-bool-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-bool-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-bool-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-bool-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-bool-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-bool-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-bool-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-bool-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-bool-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-bool-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-bool-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-bool-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-bool-uint64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-bool-uint64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-bool-uint64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-bool-uint64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-bool-uint64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-bool-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-bool-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-bool-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-bool-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-bool-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-bool-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-bool-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-bool-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-bool-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-bool-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-bool-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "compare-int8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + } + }, + { + "id": "mixed-int8-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "mixed-int8-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "mixed-int8-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "mixed-int8-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "mixed-int8-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "compare-int8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + } + }, + { + "id": "mixed-int8-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "mixed-int8-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "mixed-int8-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "mixed-int8-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "mixed-int8-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-int8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-int8-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int8-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int8-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-int8-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-int8-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int8-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-int8-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-int8-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-int8-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-int8-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int8-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int8-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int8-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int8-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int8-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int8-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int8-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int8-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int8-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int8-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int8-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int8-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int8-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int8-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int8-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int8-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int8-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int8-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int8-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int8-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-int8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-int8-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int8-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int8-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-int8-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-int8-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int8-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-int8-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-int8-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-int8-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-int8-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int8-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int8-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int8-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int8-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int8-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int8-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int8-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int8-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int8-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int8-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int8-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int8-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int8-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int8-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int8-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int8-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int8-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int8-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int8-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int8-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int8-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int8-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-int8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-int8-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-int8-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-int8-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-int8-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-int8-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-int8-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int8-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int8-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-int16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-int16-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-int16-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-int16-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-int16-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-int16-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-int16-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-int16-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-int16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-int16-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-int16-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-int16-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-int16-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-int16-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-int16-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-int16-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-int16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-int16-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-int16-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-int16-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-int16-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-int16-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-int16-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-int16-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int16-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int16-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int16-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int16-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int16-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int16-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int16-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int16-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int16-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int16-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int16-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int16-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int16-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int16-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int16-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int16-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int16-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int16-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int16-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int16-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-int16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-int16-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-int16-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-int16-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-int16-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-int16-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-int16-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-int16-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int16-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int16-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int16-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int16-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int16-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int16-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int16-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int16-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int16-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int16-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int16-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int16-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int16-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int16-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int16-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int16-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int16-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int16-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int16-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int16-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int16-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int16-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-int16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-int16-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-int16-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-int16-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-int16-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-int16-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-int16-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int16-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int16-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int32-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int32-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int32-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int32-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int32-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int32-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int32-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int32-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int32-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int32-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int32-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int32-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int32-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int32-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int32-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int32-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int32-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int32-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int32-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int32-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int32-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int32-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int32-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int32-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int32-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int32-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int32-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int32-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int32-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int32-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int32-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int32-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int32-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int32-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int32-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int32-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int32-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int32-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int32-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int32-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int32-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int32-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int32-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int32-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int32-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int32-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int32-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int32-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int32-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int32-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int32-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int32-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int32-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int32-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int32-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int32-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int32-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int32-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int32-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int32-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int32-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int32-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int32-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int32-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int32-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int64-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int64-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int64-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int64-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int64-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int64-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "compare-uint8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + } + }, + { + "id": "mixed-uint8-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "mixed-uint8-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "mixed-uint8-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "mixed-uint8-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "mixed-uint8-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-uint8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-uint8-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-uint8-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-uint8-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-uint8-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-uint8-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-uint8-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-uint8-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-uint8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-uint8-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-uint8-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-uint8-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-uint8-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-uint8-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-uint8-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-uint8-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint8-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint8-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint8-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint8-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint8-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint8-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint8-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint8-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint8-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint8-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint8-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint8-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint8-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint8-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint8-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint8-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint8-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint8-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint8-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint8-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "compare-uint8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + } + }, + { + "id": "mixed-uint8-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "mixed-uint8-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "mixed-uint8-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "mixed-uint8-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "mixed-uint8-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-uint8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-uint8-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-uint8-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-uint8-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-uint8-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-uint8-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-uint8-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-uint8-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint8-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint8-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint8-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint8-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint8-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint8-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint8-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint8-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint8-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint8-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint8-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint8-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint8-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint8-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint8-uint64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint8-uint64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint8-uint64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint8-uint64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint8-uint64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint8-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-uint8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-uint8-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-uint8-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-uint8-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-uint8-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-uint8-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-uint8-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint8-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint8-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-uint16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-uint16-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-uint16-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-uint16-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-uint16-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-uint16-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-uint16-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-uint16-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint16-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint16-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint16-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint16-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint16-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint16-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint16-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint16-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint16-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint16-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint16-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint16-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint16-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint16-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint16-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint16-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint16-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint16-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint16-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint16-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint16-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint16-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint16-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint16-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint16-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint16-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint16-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint16-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-uint16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-uint16-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-uint16-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-uint16-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-uint16-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-uint16-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-uint16-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-uint16-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-uint16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-uint16-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-uint16-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-uint16-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-uint16-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-uint16-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-uint16-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-uint16-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint16-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint16-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint16-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint16-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint16-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint16-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint16-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint16-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint16-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint16-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint16-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint16-uint64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint16-uint64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint16-uint64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint16-uint64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint16-uint64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint16-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-uint16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-uint16-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-uint16-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-uint16-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-uint16-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-uint16-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-uint16-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint16-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint16-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint32-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint32-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint32-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint32-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint32-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint32-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint32-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint32-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint32-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint32-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint32-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint32-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint32-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint32-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint32-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint32-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint32-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint32-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint32-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint32-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint32-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint32-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint32-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint32-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint32-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint32-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint32-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint32-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint32-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint32-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint32-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint32-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-uint64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-uint64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-uint64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint32-uint64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint64-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint64-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint64-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint64-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint64-uint64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-float32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-float32-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-float32-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-float32-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-float32-bool-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-bool-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-bool-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-bool-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-bool-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-float32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-float32-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-float32-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-float32-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-float32-int8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-float32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-float32-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-float32-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-float32-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-float32-int16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float32-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float32-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float32-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float32-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-float32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-float32-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-float32-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-float32-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-float32-uint8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-float32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-float32-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-float32-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-float32-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-float32-uint16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float32-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float32-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float32-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float32-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-float32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-float32-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-float32-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-float32-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-float32-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float32-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float32-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-bool-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-bool-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-bool-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-bool-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-bool-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "operator-bool-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "operator-bool-subtract", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "operator-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000000000000000000007ff0000000000000" + } + }, + { + "id": "operator-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "operator-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "operator-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "operator-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "operator-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "operator-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "operator-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "020001" + } + }, + { + "id": "operator-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "operator-bool-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "operator-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "operator-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "operator-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "operator-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "operator-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "unary-bool-positive", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "unary-bool-negative", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "unary-bool-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "unary-bool-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "weak-bool-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000200000000000000010000000000000002" + } + }, + { + "id": "weak-compare-bool-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "weak-compare-bool-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "weak-bool-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000008100000000000000800000000000000081" + } + }, + { + "id": "weak-compare-bool-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "weak-compare-bool-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "weak-bool-negative-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff0000000000000000" + } + }, + { + "id": "weak-compare-bool-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "weak-compare-bool-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "weak-bool-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff80000000000003fe00000000000003ff8000000000000" + } + }, + { + "id": "weak-compare-bool-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "weak-compare-bool-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "operator-int8-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "81810001fcfc" + } + }, + { + "id": "operator-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7f7d0001f6fe" + } + }, + { + "id": "operator-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80fe0000eb03" + } + }, + { + "id": "operator-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c060000000000000404fc000000000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000" + } + }, + { + "id": "operator-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "803f0000fd03" + } + }, + { + "id": "operator-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100000200" + } + }, + { + "id": "operator-int8-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0002000001fd" + } + }, + { + "id": "operator-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "817f0001fbff" + } + }, + { + "id": "operator-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "817d0001fa02" + } + }, + { + "id": "operator-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fc0001c800" + } + }, + { + "id": "operator-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c01f0001ffff" + } + }, + { + "id": "operator-int8-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + } + }, + { + "id": "operator-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "operator-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + } + }, + { + "id": "operator-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + } + }, + { + "id": "unary-int8-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "807f0001f9fd" + } + }, + { + "id": "unary-int8-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "808100ff0703" + } + }, + { + "id": "unary-int8-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "807f00010703" + } + }, + { + "id": "unary-int8-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7f80fffe0602" + } + }, + { + "id": "integer-divisor-boundary-int8-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000" + } + }, + { + "id": "integer-divisor-boundary-int8-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "shift-boundary-int8-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80fe00000000" + } + }, + { + "id": "shift-boundary-int8-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "803f0000ffff" + } + }, + { + "id": "weak-int8-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "81800102fafe" + } + }, + { + "id": "weak-compare-int8-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-int8-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "weak-int8-128", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "weak-compare-int8-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int8-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010101" + } + }, + { + "id": "weak-int8-negative-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7f7eff00f8fc" + } + }, + { + "id": "weak-compare-int8-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int8-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "weak-int8-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c05fe00000000000405fe000000000003fe00000000000003ff8000000000000c01a000000000000c004000000000000" + } + }, + { + "id": "weak-compare-int8-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int8-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-int16-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8001800100000001fffcfffc" + } + }, + { + "id": "operator-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fff7ffd00000001fff6fffe" + } + }, + { + "id": "operator-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000fffe00000000ffeb0003" + } + }, + { + "id": "operator-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0e000000000000040cfffc0000000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000" + } + }, + { + "id": "operator-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80003fff00000000fffd0003" + } + }, + { + "id": "operator-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000000020000" + } + }, + { + "id": "operator-int16-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000002000000000001fffd" + } + }, + { + "id": "operator-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80017fff00000001fffbffff" + } + }, + { + "id": "operator-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80017ffd00000001fffa0002" + } + }, + { + "id": "operator-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffc00000001ffc80000" + } + }, + { + "id": "operator-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0001fff00000001ffffffff" + } + }, + { + "id": "operator-int16-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + } + }, + { + "id": "operator-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "operator-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + } + }, + { + "id": "operator-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + } + }, + { + "id": "unary-int16-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001fff9fffd" + } + }, + { + "id": "unary-int16-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800080010000ffff00070003" + } + }, + { + "id": "unary-int16-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80007fff0000000100070003" + } + }, + { + "id": "unary-int16-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fff8000fffffffe00060002" + } + }, + { + "id": "integer-divisor-boundary-int16-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000000000" + } + }, + { + "id": "integer-divisor-boundary-int16-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "shift-boundary-int16-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000fffe0000000000000000" + } + }, + { + "id": "shift-boundary-int16-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80003fff00000000ffffffff" + } + }, + { + "id": "weak-int16-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8001800000010002fffafffe" + } + }, + { + "id": "weak-compare-int16-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-int16-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "weak-int16-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8080807f008000810079007d" + } + }, + { + "id": "weak-compare-int16-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int16-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + } + }, + { + "id": "weak-int16-negative-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fff7ffeffff0000fff8fffc" + } + }, + { + "id": "weak-compare-int16-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int16-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "weak-int16-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0dfffe00000000040dfffe0000000003fe00000000000003ff8000000000000c01a000000000000c004000000000000" + } + }, + { + "id": "weak-compare-int16-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int16-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-int32-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000001800000010000000000000001fffffffcfffffffc" + } + }, + { + "id": "operator-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff7ffffffd0000000000000001fffffff6fffffffe" + } + }, + { + "id": "operator-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000fffffffe0000000000000000ffffffeb00000003" + } + }, + { + "id": "operator-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1e000000000000041cfffffffc000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000" + } + }, + { + "id": "operator-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000003fffffff0000000000000000fffffffd00000003" + } + }, + { + "id": "operator-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000000000000200000000" + } + }, + { + "id": "operator-int32-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000002000000000000000000000001fffffffd" + } + }, + { + "id": "operator-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000017fffffff0000000000000001fffffffbffffffff" + } + }, + { + "id": "operator-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000017ffffffd0000000000000001fffffffa00000002" + } + }, + { + "id": "operator-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffc0000000000000001ffffffc800000000" + } + }, + { + "id": "operator-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c00000001fffffff0000000000000001ffffffffffffffff" + } + }, + { + "id": "operator-int32-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + } + }, + { + "id": "operator-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "operator-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + } + }, + { + "id": "operator-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + } + }, + { + "id": "unary-int32-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001fffffff9fffffffd" + } + }, + { + "id": "unary-int32-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000008000000100000000ffffffff0000000700000003" + } + }, + { + "id": "unary-int32-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff00000000000000010000000700000003" + } + }, + { + "id": "unary-int32-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff80000000fffffffffffffffe0000000600000002" + } + }, + { + "id": "integer-divisor-boundary-int32-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000000000000000000000" + } + }, + { + "id": "integer-divisor-boundary-int32-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "shift-boundary-int32-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000fffffffe00000000000000000000000000000000" + } + }, + { + "id": "shift-boundary-int32-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000003fffffff0000000000000000ffffffffffffffff" + } + }, + { + "id": "weak-int32-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000001800000000000000100000002fffffffafffffffe" + } + }, + { + "id": "weak-compare-int32-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-int32-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "weak-int32-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000808000007f0000008000000081000000790000007d" + } + }, + { + "id": "weak-compare-int32-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int32-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + } + }, + { + "id": "weak-int32-negative-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff7ffffffeffffffff00000000fffffff8fffffffc" + } + }, + { + "id": "weak-compare-int32-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int32-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "weak-int32-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1dfffffffe0000041dfffffffe000003fe00000000000003ff8000000000000c01a000000000000c004000000000000" + } + }, + { + "id": "weak-compare-int32-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int32-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-int64-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000001800000000000000100000000000000000000000000000001fffffffffffffffcfffffffffffffffc" + } + }, + { + "id": "operator-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff7ffffffffffffffd00000000000000000000000000000001fffffffffffffff6fffffffffffffffe" + } + }, + { + "id": "operator-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000000fffffffffffffffe00000000000000000000000000000000ffffffffffffffeb0000000000000003" + } + }, + { + "id": "operator-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043d00000000000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000" + } + }, + { + "id": "operator-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000003fffffffffffffff00000000000000000000000000000000fffffffffffffffd0000000000000003" + } + }, + { + "id": "operator-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000000000000000000000000000000000020000000000000000" + } + }, + { + "id": "operator-int64-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000002000000000000000000000000000000000000000000000001fffffffffffffffd" + } + }, + { + "id": "operator-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000017fffffffffffffff00000000000000000000000000000001fffffffffffffffbffffffffffffffff" + } + }, + { + "id": "operator-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000017ffffffffffffffd00000000000000000000000000000001fffffffffffffffa0000000000000002" + } + }, + { + "id": "operator-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffc00000000000000000000000000000001ffffffffffffffc80000000000000000" + } + }, + { + "id": "operator-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0000000000000001fffffffffffffff00000000000000000000000000000001ffffffffffffffffffffffffffffffff" + } + }, + { + "id": "operator-int64-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + } + }, + { + "id": "operator-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "operator-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + } + }, + { + "id": "operator-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + } + }, + { + "id": "unary-int64-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001fffffffffffffff9fffffffffffffffd" + } + }, + { + "id": "unary-int64-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000000000000080000000000000010000000000000000ffffffffffffffff00000000000000070000000000000003" + } + }, + { + "id": "unary-int64-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff0000000000000000000000000000000100000000000000070000000000000003" + } + }, + { + "id": "unary-int64-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff8000000000000000fffffffffffffffffffffffffffffffe00000000000000060000000000000002" + } + }, + { + "id": "integer-divisor-boundary-int64-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000000000000000000000000000000000000000000000" + } + }, + { + "id": "integer-divisor-boundary-int64-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "shift-boundary-int64-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000000fffffffffffffffe0000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "id": "shift-boundary-int64-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000003fffffffffffffff00000000000000000000000000000000ffffffffffffffffffffffffffffffff" + } + }, + { + "id": "weak-int64-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000001800000000000000000000000000000010000000000000002fffffffffffffffafffffffffffffffe" + } + }, + { + "id": "weak-compare-int64-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-int64-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "weak-int64-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000080800000000000007f000000000000008000000000000000810000000000000079000000000000007d" + } + }, + { + "id": "weak-compare-int64-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int64-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + } + }, + { + "id": "weak-int64-negative-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff7ffffffffffffffeffffffffffffffff0000000000000000fffffffffffffff8fffffffffffffffc" + } + }, + { + "id": "weak-compare-int64-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int64-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "weak-int64-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043e00000000000003fe00000000000003ff8000000000000c01a000000000000c004000000000000" + } + }, + { + "id": "weak-compare-int64-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int64-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-uint8-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010406" + } + }, + { + "id": "operator-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffd00010000" + } + }, + { + "id": "operator-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fe00000409" + } + }, + { + "id": "operator-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000405fe000000000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "operator-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "007f00000101" + } + }, + { + "id": "operator-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100000000" + } + }, + { + "id": "operator-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00010101041b" + } + }, + { + "id": "operator-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000200000203" + } + }, + { + "id": "operator-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "01ff00010203" + } + }, + { + "id": "operator-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "01fd00010000" + } + }, + { + "id": "operator-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fc00010818" + } + }, + { + "id": "operator-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "003f00010000" + } + }, + { + "id": "operator-uint8-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + } + }, + { + "id": "operator-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + } + }, + { + "id": "operator-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + } + }, + { + "id": "operator-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + } + }, + { + "id": "unary-uint8-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00ff00010203" + } + }, + { + "id": "unary-uint8-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100fffefd" + } + }, + { + "id": "unary-uint8-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00ff00010203" + } + }, + { + "id": "unary-uint8-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ff00fffefdfc" + } + }, + { + "id": "integer-divisor-boundary-uint8-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "integer-divisor-boundary-uint8-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "shift-boundary-uint8-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fe00000000" + } + }, + { + "id": "shift-boundary-uint8-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "007f00000000" + } + }, + { + "id": "weak-uint8-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001020304" + } + }, + { + "id": "weak-compare-uint8-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-uint8-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "weak-uint8-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "807f80818283" + } + }, + { + "id": "weak-compare-uint8-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint8-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + } + }, + { + "id": "weak-uint8-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "weak-compare-uint8-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint8-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-uint8-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe0000000000000406ff000000000003fe00000000000003ff80000000000004004000000000000400c000000000000" + } + }, + { + "id": "weak-compare-uint8-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint8-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "operator-uint16-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000000100040006" + } + }, + { + "id": "operator-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffffffd0000000100000000" + } + }, + { + "id": "operator-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffe0000000000040009" + } + }, + { + "id": "operator-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040dfffe0000000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "operator-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00007fff0000000000010001" + } + }, + { + "id": "operator-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000000000000" + } + }, + { + "id": "operator-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000001000100010004001b" + } + }, + { + "id": "operator-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000020000000000020003" + } + }, + { + "id": "operator-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0001ffff0000000100020003" + } + }, + { + "id": "operator-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0001fffd0000000100000000" + } + }, + { + "id": "operator-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffc0000000100080018" + } + }, + { + "id": "operator-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00003fff0000000100000000" + } + }, + { + "id": "operator-uint16-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + } + }, + { + "id": "operator-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + } + }, + { + "id": "operator-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + } + }, + { + "id": "operator-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + } + }, + { + "id": "unary-uint16-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff0000000100020003" + } + }, + { + "id": "unary-uint16-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000fffffffefffd" + } + }, + { + "id": "unary-uint16-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff0000000100020003" + } + }, + { + "id": "unary-uint16-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ffff0000fffffffefffdfffc" + } + }, + { + "id": "integer-divisor-boundary-uint16-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "integer-divisor-boundary-uint16-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "shift-boundary-uint16-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffe0000000000000000" + } + }, + { + "id": "shift-boundary-uint16-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00007fff0000000000000000" + } + }, + { + "id": "weak-uint16-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100000001000200030004" + } + }, + { + "id": "weak-compare-uint16-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-uint16-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "weak-uint16-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0080007f0080008100820083" + } + }, + { + "id": "weak-compare-uint16-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint16-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + } + }, + { + "id": "weak-uint16-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "weak-compare-uint16-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint16-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-uint16-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe000000000000040effff0000000003fe00000000000003ff80000000000004004000000000000400c000000000000" + } + }, + { + "id": "weak-compare-uint16-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint16-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "operator-uint32-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000000000010000000400000006" + } + }, + { + "id": "operator-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffffffffffffffd00000000000000010000000000000000" + } + }, + { + "id": "operator-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffe00000000000000000000000400000009" + } + }, + { + "id": "operator-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000041dfffffffe000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "operator-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000007fffffff00000000000000000000000100000001" + } + }, + { + "id": "operator-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000000000000000000000" + } + }, + { + "id": "operator-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000100000001000000040000001b" + } + }, + { + "id": "operator-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000200000000000000000000000200000003" + } + }, + { + "id": "operator-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000001ffffffff00000000000000010000000200000003" + } + }, + { + "id": "operator-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000001fffffffd00000000000000010000000000000000" + } + }, + { + "id": "operator-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffc00000000000000010000000800000018" + } + }, + { + "id": "operator-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000003fffffff00000000000000010000000000000000" + } + }, + { + "id": "operator-uint32-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + } + }, + { + "id": "operator-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + } + }, + { + "id": "operator-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + } + }, + { + "id": "operator-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + } + }, + { + "id": "unary-uint32-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff00000000000000010000000200000003" + } + }, + { + "id": "unary-uint32-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000fffffffffffffffefffffffd" + } + }, + { + "id": "unary-uint32-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff00000000000000010000000200000003" + } + }, + { + "id": "unary-uint32-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff00000000fffffffffffffffefffffffdfffffffc" + } + }, + { + "id": "integer-divisor-boundary-uint32-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "integer-divisor-boundary-uint32-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "shift-boundary-uint32-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffe00000000000000000000000000000000" + } + }, + { + "id": "shift-boundary-uint32-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000007fffffff00000000000000000000000000000000" + } + }, + { + "id": "weak-uint32-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000000000001000000020000000300000004" + } + }, + { + "id": "weak-compare-uint32-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-uint32-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "weak-uint32-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000800000007f00000080000000810000008200000083" + } + }, + { + "id": "weak-compare-uint32-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint32-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + } + }, + { + "id": "weak-uint32-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "weak-compare-uint32-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint32-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-uint32-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe000000000000041effffffff000003fe00000000000003ff80000000000004004000000000000400c000000000000" + } + }, + { + "id": "weak-compare-uint32-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint32-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "operator-uint64-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000000000000000000100000000000000040000000000000006" + } + }, + { + "id": "operator-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffffffffffffffffffffffffffffffd0000000000000000000000000000000100000000000000000000000000000000" + } + }, + { + "id": "operator-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffe0000000000000000000000000000000000000000000000040000000000000009" + } + }, + { + "id": "operator-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000043e00000000000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "operator-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007fffffffffffffff0000000000000000000000000000000000000000000000010000000000000001" + } + }, + { + "id": "operator-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "id": "operator-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001000000000000000100000000000000010000000000000004000000000000001b" + } + }, + { + "id": "operator-uint64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000020000000000000000000000000000000000000000000000020000000000000003" + } + }, + { + "id": "operator-uint64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001ffffffffffffffff0000000000000000000000000000000100000000000000020000000000000003" + } + }, + { + "id": "operator-uint64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001fffffffffffffffd0000000000000000000000000000000100000000000000000000000000000000" + } + }, + { + "id": "operator-uint64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffc0000000000000000000000000000000100000000000000080000000000000018" + } + }, + { + "id": "operator-uint64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fffffffffffffff0000000000000000000000000000000100000000000000000000000000000000" + } + }, + { + "id": "operator-uint64-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + } + }, + { + "id": "operator-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + } + }, + { + "id": "operator-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + } + }, + { + "id": "operator-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + } + }, + { + "id": "unary-uint64-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff0000000000000000000000000000000100000000000000020000000000000003" + } + }, + { + "id": "unary-uint64-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000fffffffffffffffffffffffffffffffefffffffffffffffd" + } + }, + { + "id": "unary-uint64-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff0000000000000000000000000000000100000000000000020000000000000003" + } + }, + { + "id": "unary-uint64-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff0000000000000000fffffffffffffffffffffffffffffffefffffffffffffffdfffffffffffffffc" + } + }, + { + "id": "integer-divisor-boundary-uint64-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "integer-divisor-boundary-uint64-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "shift-boundary-uint64-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffe0000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "id": "shift-boundary-uint64-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007fffffffffffffff0000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "id": "weak-uint64-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000000000000000000001000000000000000200000000000000030000000000000004" + } + }, + { + "id": "weak-compare-uint64-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-uint64-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "weak-uint64-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000080000000000000007f0000000000000080000000000000008100000000000000820000000000000083" + } + }, + { + "id": "weak-compare-uint64-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint64-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + } + }, + { + "id": "weak-uint64-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "weak-compare-uint64-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint64-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-uint64-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe000000000000043f00000000000003fe00000000000003ff80000000000004004000000000000400c000000000000" + } + }, + { + "id": "weak-compare-uint64-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint64-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "operator-float32-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0800000c080000000000000400000003e4ccccd3f8ccccd" + } + }, + { + "id": "operator-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1200000c000000000000000c0000000000000003f666666" + } + }, + { + "id": "operator-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1a800004040000000000000800000003c23d70b3dcccccd" + } + }, + { + "id": "operator-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0155555404000007fc00000800000003f80000041200000" + } + }, + { + "id": "operator-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0400000404000007fc00000800000003f80000041100000" + } + }, + { + "id": "operator-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "40000000800000007fc0000000000000000000003dcccccb" + } + }, + { + "id": "operator-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c3ab8000beaaaaab3f800000000000003f4b59183f800000" + } + }, + { + "id": "operator-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float32-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000100" + } + }, + { + "id": "operator-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + } + }, + { + "id": "operator-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010001" + } + }, + { + "id": "operator-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + } + }, + { + "id": "operator-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "operator-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + } + }, + { + "id": "unary-float32-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0e00000c040000000000000800000003dcccccd3f800000" + } + }, + { + "id": "unary-float32-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "40e00000404000008000000000000000bdcccccdbf800000" + } + }, + { + "id": "unary-float32-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "40e000004040000000000000000000003dcccccd3f800000" + } + }, + { + "id": "unary-float32-invert", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "weak-float32-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0c00000c00000003f8000003f8000003f8ccccd40000000" + } + }, + { + "id": "weak-compare-float32-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "weak-compare-float32-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + } + }, + { + "id": "weak-float32-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "42f2000042fa000043000000430000004300199a43010000" + } + }, + { + "id": "weak-compare-float32-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-float32-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010101" + } + }, + { + "id": "weak-float32-negative-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1000000c0800000bf800000bf800000bf66666600000000" + } + }, + { + "id": "weak-compare-float32-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-float32-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100000000" + } + }, + { + "id": "weak-float32-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0d00000c02000003f0000003f0000003f19999a3fc00000" + } + }, + { + "id": "weak-compare-float32-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-float32-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + } + }, + { + "id": "operator-float64-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c010000000000000c010000000000000000000000000000040000000000000003fc999999999999a3ff199999999999a" + } + }, + { + "id": "operator-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c024000000000000c0000000000000000000000000000000c00000000000000000000000000000003feccccccccccccd" + } + }, + { + "id": "operator-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0350000000000004008000000000000000000000000000080000000000000003f847ae147ae147c3fb999999999999a" + } + }, + { + "id": "operator-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c002aaaaaaaaaaab40080000000000007ff800000000000080000000000000003ff00000000000004024000000000000" + } + }, + { + "id": "operator-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c00800000000000040080000000000007ff800000000000080000000000000003ff00000000000004022000000000000" + } + }, + { + "id": "operator-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "400000000000000080000000000000007ff8000000000000000000000000000000000000000000003fb9999999999996" + } + }, + { + "id": "operator-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c075700000000000bfd55555555555553ff000000000000000000000000000003fe96b230bcdc4343ff0000000000000" + } + }, + { + "id": "operator-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float64-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000100" + } + }, + { + "id": "operator-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + } + }, + { + "id": "operator-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010001" + } + }, + { + "id": "operator-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + } + }, + { + "id": "operator-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "operator-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + } + }, + { + "id": "unary-float64-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c01c000000000000c008000000000000000000000000000080000000000000003fb999999999999a3ff0000000000000" + } + }, + { + "id": "unary-float64-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "401c000000000000400800000000000080000000000000000000000000000000bfb999999999999abff0000000000000" + } + }, + { + "id": "unary-float64-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "401c0000000000004008000000000000000000000000000000000000000000003fb999999999999a3ff0000000000000" + } + }, + { + "id": "unary-float64-invert", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "weak-float64-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c018000000000000c0000000000000003ff00000000000003ff00000000000003ff199999999999a4000000000000000" + } + }, + { + "id": "weak-compare-float64-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "weak-compare-float64-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + } + }, + { + "id": "weak-float64-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "405e400000000000405f4000000000004060000000000000406000000000000040600333333333334060200000000000" + } + }, + { + "id": "weak-compare-float64-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-float64-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010101" + } + }, + { + "id": "weak-float64-negative-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c020000000000000c010000000000000bff0000000000000bff0000000000000bfeccccccccccccd0000000000000000" + } + }, + { + "id": "weak-compare-float64-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-float64-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100000000" + } + }, + { + "id": "weak-float64-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c01a000000000000c0040000000000003fe00000000000003fe00000000000003fe33333333333333ff8000000000000" + } + }, + { + "id": "weak-compare-float64-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-float64-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + } + }, + { + "id": "cast-bool-bool-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-bool-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-int8-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-int16-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-bool-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-bool-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-bool-int32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-bool-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-bool-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-bool-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-bool-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-bool-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-bool-uint8-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-uint8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-uint16-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-bool-uint16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-bool-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-bool-uint32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-bool-uint32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-bool-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-bool-uint64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-bool-uint64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-bool-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-bool-float32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-bool-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-bool-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-bool-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-bool-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-bool-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int8-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int8-int8-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int8-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int8-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int8-int16-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int8-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int8-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int8-int32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int8-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int8-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int8-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int8-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int8-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int8-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int8-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int8-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int8-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int8-float32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int8-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int8-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int8-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int8-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int8-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int16-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int16-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int16-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int16-int16-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int16-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int16-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int16-int32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int16-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int16-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int16-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int16-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int16-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int16-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int16-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int16-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int16-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int16-float32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int16-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int16-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int16-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int16-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int16-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int32-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int32-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int32-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int32-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int32-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int32-int32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int32-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int32-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int32-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int32-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int32-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int32-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int32-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int32-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int32-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int32-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int32-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int32-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int32-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int32-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int64-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int64-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int64-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int64-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int64-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int64-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int64-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int64-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int64-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int64-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int64-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int64-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int64-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int64-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int64-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int64-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int64-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int64-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int64-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint8-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint8-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint8-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint8-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint8-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint8-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint8-int16-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint8-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint8-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint8-int32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint8-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint8-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint8-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint8-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint8-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint8-uint8-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint8-uint8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint8-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint8-uint16-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint8-uint16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint8-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint8-uint32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint8-uint32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint8-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint8-uint64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint8-uint64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint8-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint8-float32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint8-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint8-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint8-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint8-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint8-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint16-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint16-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint16-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint16-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint16-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint16-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint16-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint16-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint16-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint16-int32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint16-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint16-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint16-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint16-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint16-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint16-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint16-uint8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint16-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint16-uint16-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint16-uint16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint16-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint16-uint32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint16-uint32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint16-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint16-uint64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint16-uint64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint16-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint16-float32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint16-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint16-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint16-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint16-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint16-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint32-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint32-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint32-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint32-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint32-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint32-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint32-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint32-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint32-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint32-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint32-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-uint8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint32-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint32-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-uint16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint32-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint32-uint32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint32-uint32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint32-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint32-uint64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint32-uint64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint32-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint32-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint32-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint32-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint32-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint32-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint64-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint64-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint64-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint64-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint64-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint64-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint64-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint64-int64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint64-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint64-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-uint8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint64-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint64-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-uint16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint64-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint64-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-uint32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint64-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint64-uint64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint64-uint64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint64-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint64-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint64-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint64-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint64-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint64-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-float32-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-float32-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-float32-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-float32-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-float32-int64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-float32-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-float32-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-float32-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-float32-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-float32-float32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-float32-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-float32-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-float32-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-float32-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-float32-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-float64-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-float64-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-float64-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-float64-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-float64-int64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-float64-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-float64-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-float64-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-float64-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-float64-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-float64-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-float64-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-float64-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-float64-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-int8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "explicit-int8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "cast-boundary-int8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + } + }, + { + "id": "explicit-int8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + } + }, + { + "id": "cast-boundary-int8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + } + }, + { + "id": "explicit-int8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + } + }, + { + "id": "cast-boundary-int8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + } + }, + { + "id": "explicit-int8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + } + }, + { + "id": "cast-boundary-int8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + } + }, + { + "id": "explicit-int8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + } + }, + { + "id": "explicit-int8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + } + }, + { + "id": "cast-boundary-int8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + } + }, + { + "id": "explicit-int8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + } + }, + { + "id": "cast-boundary-int8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + } + }, + { + "id": "explicit-int8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + } + }, + { + "id": "cast-boundary-int8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + } + }, + { + "id": "explicit-int8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c300000042fe0000000000003f800000" + } + }, + { + "id": "explicit-int8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c300000042fe0000000000003f800000" + } + }, + { + "id": "cast-boundary-int8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c060000000000000405fc0000000000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-int8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c060000000000000405fc0000000000000000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-int16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "explicit-int16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "cast-boundary-int16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-int16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-int16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + } + }, + { + "id": "explicit-int16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + } + }, + { + "id": "cast-boundary-int16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + } + }, + { + "id": "explicit-int16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + } + }, + { + "id": "cast-boundary-int16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + } + }, + { + "id": "explicit-int16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-int16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-int16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + } + }, + { + "id": "explicit-int16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + } + }, + { + "id": "cast-boundary-int16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + } + }, + { + "id": "explicit-int16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + } + }, + { + "id": "cast-boundary-int16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + } + }, + { + "id": "explicit-int16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c700000046fffe00000000003f800000" + } + }, + { + "id": "explicit-int16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c700000046fffe00000000003f800000" + } + }, + { + "id": "cast-boundary-int16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c0e000000000000040dfffc00000000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-int16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c0e000000000000040dfffc00000000000000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-int32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "explicit-int32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "cast-boundary-int32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-int32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-int32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-int32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-int32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + } + }, + { + "id": "explicit-int32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + } + }, + { + "id": "cast-boundary-int32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-int32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-int32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-int32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-int32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-int32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + } + }, + { + "id": "explicit-int32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + } + }, + { + "id": "cast-boundary-int32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-int32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "cf0000004f000000000000003f800000" + } + }, + { + "id": "explicit-int32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "cf0000004f000000000000003f800000" + } + }, + { + "id": "cast-boundary-int32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c1e000000000000041dfffffffc0000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-int32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c1e000000000000041dfffffffc0000000000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-int64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "explicit-int64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "cast-boundary-int64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-int64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-int64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-int64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-int64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "explicit-int64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "cast-boundary-int64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-int64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-int64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-int64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-int64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-int64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "explicit-int64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "cast-boundary-int64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-int64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "df0000005f000000000000003f800000" + } + }, + { + "id": "explicit-int64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "df0000005f000000000000003f800000" + } + }, + { + "id": "cast-boundary-int64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043e000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-int64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043e000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-uint8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "explicit-uint8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "cast-boundary-uint8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + } + }, + { + "id": "explicit-uint8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + } + }, + { + "id": "cast-boundary-uint8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + } + }, + { + "id": "explicit-uint8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + } + }, + { + "id": "cast-boundary-uint8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + } + }, + { + "id": "explicit-uint8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + } + }, + { + "id": "cast-boundary-uint8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + } + }, + { + "id": "explicit-uint8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + } + }, + { + "id": "cast-boundary-uint8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000437f0000000000003f800000" + } + }, + { + "id": "explicit-uint8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000437f0000000000003f800000" + } + }, + { + "id": "cast-boundary-uint8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000406fe0000000000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-uint8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000406fe0000000000000000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-uint16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "explicit-uint16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "cast-boundary-uint16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-uint16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-uint16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + } + }, + { + "id": "explicit-uint16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + } + }, + { + "id": "cast-boundary-uint16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-uint16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-uint16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + } + }, + { + "id": "explicit-uint16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + } + }, + { + "id": "cast-boundary-uint16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000477fff00000000003f800000" + } + }, + { + "id": "explicit-uint16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000477fff00000000003f800000" + } + }, + { + "id": "cast-boundary-uint16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040efffe00000000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-uint16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040efffe00000000000000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-uint32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "explicit-uint32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "cast-boundary-uint32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-uint32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-uint32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "explicit-uint32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "cast-boundary-uint32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-uint32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-uint32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "explicit-uint32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "cast-boundary-uint32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000004f800000000000003f800000" + } + }, + { + "id": "explicit-uint32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000004f800000000000003f800000" + } + }, + { + "id": "cast-boundary-uint32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000041efffffffe0000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-uint32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000041efffffffe0000000000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-uint64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "explicit-uint64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "cast-boundary-uint64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-uint64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-uint64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "explicit-uint64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "cast-boundary-uint64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-uint64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-uint64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "explicit-uint64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "cast-boundary-uint64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000005f800000000000003f800000" + } + }, + { + "id": "explicit-uint64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000005f800000000000003f800000" + } + }, + { + "id": "cast-boundary-uint64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000043f000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-uint64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000043f000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "float-cast-float32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "0100000101" + } + }, + { + "id": "float-cast-float32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ff0000017f" + } + }, + { + "id": "float-cast-float32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffff000000000001007f" + } + }, + { + "id": "float-cast-float32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000000000000000000010000007f" + } + }, + { + "id": "float-cast-float32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff000000000000000000000000000000000000000000000001000000000000007f" + } + }, + { + "id": "float-cast-float32-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float32-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float32-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float32-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bff3333380000000000000003ff3333342ffcccd" + } + }, + { + "id": "float-cast-float32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bffe666660000000800000000000000000000000000000003ffe666660000000405ff999a0000000" + } + }, + { + "id": "nonfinite-cast-float32-int8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float32-int16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float32-int32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float32-int64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float32-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float32-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float32-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float32-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "0100000101" + } + }, + { + "id": "float-cast-float64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ff0000017f" + } + }, + { + "id": "float-cast-float64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffff000000000001007f" + } + }, + { + "id": "float-cast-float64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000000000000000000010000007f" + } + }, + { + "id": "float-cast-float64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff000000000000000000000000000000000000000000000001000000000000007f" + } + }, + { + "id": "float-cast-float64-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float64-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float64-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float64-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bff3333380000000000000003ff3333342ffcccd" + } + }, + { + "id": "float-cast-float64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bffe666666666666800000000000000000000000000000003ffe666666666666405ff9999999999a" + } + }, + { + "id": "nonfinite-cast-float64-int8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float64-int16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float64-int32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float64-int64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float64-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float64-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float64-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float64-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "intermediate-not-output-driven", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000002" + } + }, + { + "id": "power-wrapping-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7f0001" + } + }, + { + "id": "power-wrapping-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fff04000001" + } + }, + { + "id": "power-wrapping-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff0000040000000001" + } + }, + { + "id": "power-wrapping-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff00000000000004000000000000000001" + } + }, + { + "id": "power-wrapping-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0001" + } + }, + { + "id": "power-wrapping-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff04000001" + } + }, + { + "id": "power-wrapping-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000040000000001" + } + }, + { + "id": "power-wrapping-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000004000000000000000001" + } + }, + { + "id": "comparison-rounded-int64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "00" + } + }, + { + "id": "comparison-rounded-uint64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "00" + } + }, + { + "id": "capture-int8-weak-int", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010203" + } + }, + { + "id": "capture-int8-weak-float", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000" + } + }, + { + "id": "capture-int8-typed-int", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000020000000000000003" + } + }, + { + "id": "capture-int8-typed-float", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000" + } + }, + { + "id": "capture-int8-typed-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f0000003fc0000040200000" + } + }, + { + "id": "capture-float32-weak-int", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040400000" + } + }, + { + "id": "capture-float32-weak-float", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f0000003fc0000040200000" + } + }, + { + "id": "capture-float32-typed-int", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004008000000000000" + } + }, + { + "id": "capture-float32-typed-float", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000" + } + }, + { + "id": "capture-float32-typed-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f0000003fc0000040200000" + } + }, + { + "id": "capture-float64-weak-int", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004008000000000000" + } + }, + { + "id": "capture-float64-weak-float", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000" + } + }, + { + "id": "capture-float64-typed-int", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004008000000000000" + } + }, + { + "id": "capture-float64-typed-float", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000" + } + }, + { + "id": "capture-float64-typed-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000" + } + }, + { + "id": "noncontracting-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "00000000" + } + }, + { + "id": "float-divmod-float32-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 80, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "41100000c1200000426c0000c27000007fc000007fc00000800000008000000000000000bf800000" + } + }, + { + "id": "float-divmod-float32-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 80, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "3dcccccb328000003dccccc133c000007fc000007fc000008000000000000000404000007f800000" + } + }, + { + "id": "noncontracting-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "float-divmod-float64-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 160, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "4022000000000000c024000000000000404d800000000000c04e0000000000007ff80000000000007ff8000000000000800000000000000080000000000000000000000000000000bff0000000000000" + } + }, + { + "id": "float-divmod-float64-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 160, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "3fb99999999999963c900000000000003fb99999999999823cb80000000000007ff80000000000007ff80000000000008000000000000000000000000000000040080000000000007ff0000000000000" + } + } + ], + "python": [ + { + "id": "promotion-bool-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-subtract", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-add", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-subtract", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000000000000000000007ff0000000000000", + "classes": [ + "finite", + "positive_zero", + "positive_inf" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "020001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-bool-positive", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-bool-negative", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-bool-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-bool-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-bool-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000200000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-bool-128", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000008100000000000000800000000000000081" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-bool-negative-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff0000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-bool-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff80000000000003fe00000000000003ff8000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-add", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "81810001fcfc" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7f7d0001f6fe" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80fe0000eb03" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c060000000000000404fc000000000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000", + "classes": [ + "finite", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "803f0000fd03" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100000200" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0002000001fd" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "817f0001fbff" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "817d0001fa02" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fc0001c800" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c01f0001ffff" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int8-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "807f0001f9fd" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int8-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "808100ff0703" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int8-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "807f00010703" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int8-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7f80fffe0602" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int8-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int8-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int8-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80fe00000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int8-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "803f0000ffff" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int8-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "81800102fafe" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int8-128", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int8-negative-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7f7eff00f8fc" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int8-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c05fe00000000000405fe000000000003fe00000000000003ff8000000000000c01a000000000000c004000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-add", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8001800100000001fffcfffc" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fff7ffd00000001fff6fffe" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000fffe00000000ffeb0003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0e000000000000040cfffc0000000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000", + "classes": [ + "finite", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80003fff00000000fffd0003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000000020000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000002000000000001fffd" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80017fff00000001fffbffff" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80017ffd00000001fffa0002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffc00000001ffc80000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0001fff00000001ffffffff" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int16-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001fff9fffd" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int16-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800080010000ffff00070003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int16-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80007fff0000000100070003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int16-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fff8000fffffffe00060002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int16-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int16-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int16-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000fffe0000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int16-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80003fff00000000ffffffff" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int16-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8001800000010002fffafffe" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int16-128", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8080807f008000810079007d" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int16-negative-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fff7ffeffff0000fff8fffc" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int16-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0dfffe00000000040dfffe0000000003fe00000000000003ff8000000000000c01a000000000000c004000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-add", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000001800000010000000000000001fffffffcfffffffc" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff7ffffffd0000000000000001fffffff6fffffffe" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000fffffffe0000000000000000ffffffeb00000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1e000000000000041cfffffffc000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000", + "classes": [ + "finite", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000003fffffff0000000000000000fffffffd00000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000000000000200000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000002000000000000000000000001fffffffd" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000017fffffff0000000000000001fffffffbffffffff" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000017ffffffd0000000000000001fffffffa00000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffc0000000000000001ffffffc800000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c00000001fffffff0000000000000001ffffffffffffffff" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int32-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001fffffff9fffffffd" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int32-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000008000000100000000ffffffff0000000700000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int32-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff00000000000000010000000700000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int32-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff80000000fffffffffffffffe0000000600000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int32-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int32-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int32-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000fffffffe00000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int32-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000003fffffff0000000000000000ffffffffffffffff" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int32-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000001800000000000000100000002fffffffafffffffe" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int32-128", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000808000007f0000008000000081000000790000007d" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int32-negative-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff7ffffffeffffffff00000000fffffff8fffffffc" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int32-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1dfffffffe0000041dfffffffe000003fe00000000000003ff8000000000000c01a000000000000c004000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-add", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000001800000000000000100000000000000000000000000000001fffffffffffffffcfffffffffffffffc" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff7ffffffffffffffd00000000000000000000000000000001fffffffffffffff6fffffffffffffffe" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000000fffffffffffffffe00000000000000000000000000000000ffffffffffffffeb0000000000000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043d00000000000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000", + "classes": [ + "finite", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000003fffffffffffffff00000000000000000000000000000000fffffffffffffffd0000000000000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000000000000000000000000000000000020000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000002000000000000000000000000000000000000000000000001fffffffffffffffd" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000017fffffffffffffff00000000000000000000000000000001fffffffffffffffbffffffffffffffff" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000017ffffffffffffffd00000000000000000000000000000001fffffffffffffffa0000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffc00000000000000000000000000000001ffffffffffffffc80000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0000000000000001fffffffffffffff00000000000000000000000000000001ffffffffffffffffffffffffffffffff" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int64-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001fffffffffffffff9fffffffffffffffd" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int64-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000000000000080000000000000010000000000000000ffffffffffffffff00000000000000070000000000000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int64-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff0000000000000000000000000000000100000000000000070000000000000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int64-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff8000000000000000fffffffffffffffffffffffffffffffe00000000000000060000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int64-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int64-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int64-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000000fffffffffffffffe0000000000000000000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int64-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000003fffffffffffffff00000000000000000000000000000000ffffffffffffffffffffffffffffffff" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int64-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000001800000000000000000000000000000010000000000000002fffffffffffffffafffffffffffffffe" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int64-128", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000080800000000000007f000000000000008000000000000000810000000000000079000000000000007d" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int64-negative-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff7ffffffffffffffeffffffffffffffff0000000000000000fffffffffffffff8fffffffffffffffc" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int64-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043e00000000000003fe00000000000003ff8000000000000c01a000000000000c004000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-add", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010406" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffd00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fe00000409" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000405fe000000000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "007f00000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00010101041b" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000200000203" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "01ff00010203" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "01fd00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fc00010818" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "003f00010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint8-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00ff00010203" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint8-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100fffefd" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint8-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00ff00010203" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint8-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ff00fffefdfc" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint8-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint8-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint8-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fe00000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint8-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "007f00000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint8-1", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001020304" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint8-128", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "807f80818283" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint8-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint8-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe0000000000000406ff000000000003fe00000000000003ff80000000000004004000000000000400c000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-add", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000000100040006" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffffffd0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffe0000000000040009" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040dfffe0000000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00007fff0000000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000001000100010004001b" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000020000000000020003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0001ffff0000000100020003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0001fffd0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffc0000000100080018" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00003fff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint16-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff0000000100020003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint16-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000fffffffefffd" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint16-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff0000000100020003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint16-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ffff0000fffffffefffdfffc" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint16-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint16-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint16-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffe0000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint16-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00007fff0000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint16-1", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100000001000200030004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint16-128", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0080007f0080008100820083" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint16-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint16-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe000000000000040effff0000000003fe00000000000003ff80000000000004004000000000000400c000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-add", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000000000010000000400000006" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffffffffffffffd00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffe00000000000000000000000400000009" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000041dfffffffe000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000007fffffff00000000000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000100000001000000040000001b" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000200000000000000000000000200000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000001ffffffff00000000000000010000000200000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000001fffffffd00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffc00000000000000010000000800000018" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000003fffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint32-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff00000000000000010000000200000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint32-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000fffffffffffffffefffffffd" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint32-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff00000000000000010000000200000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint32-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff00000000fffffffffffffffefffffffdfffffffc" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint32-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint32-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint32-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffe00000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint32-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000007fffffff00000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint32-1", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000000000001000000020000000300000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint32-128", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000800000007f00000080000000810000008200000083" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint32-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint32-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe000000000000041effffffff000003fe00000000000003ff80000000000004004000000000000400c000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-add", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000000000000000000100000000000000040000000000000006" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffffffffffffffffffffffffffffffd0000000000000000000000000000000100000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffe0000000000000000000000000000000000000000000000040000000000000009" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000043e00000000000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007fffffffffffffff0000000000000000000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001000000000000000100000000000000010000000000000004000000000000001b" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000020000000000000000000000000000000000000000000000020000000000000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001ffffffffffffffff0000000000000000000000000000000100000000000000020000000000000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001fffffffffffffffd0000000000000000000000000000000100000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffc0000000000000000000000000000000100000000000000080000000000000018" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fffffffffffffff0000000000000000000000000000000100000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint64-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff0000000000000000000000000000000100000000000000020000000000000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint64-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000fffffffffffffffffffffffffffffffefffffffffffffffd" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint64-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff0000000000000000000000000000000100000000000000020000000000000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint64-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff0000000000000000fffffffffffffffffffffffffffffffefffffffffffffffdfffffffffffffffc" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint64-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint64-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint64-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffe0000000000000000000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint64-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007fffffffffffffff0000000000000000000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint64-1", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000000000000000000001000000000000000200000000000000030000000000000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint64-128", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000080000000000000007f0000000000000080000000000000008100000000000000820000000000000083" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint64-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint64-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe000000000000043f00000000000003fe00000000000003ff80000000000004004000000000000400c000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-add", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0800000c080000000000000400000003e4ccccd3f8ccccd", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1200000c000000000000000c0000000000000003f666666", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1a800004040000000000000800000003c23d70b3dcccccd", + "classes": [ + "finite", + "finite", + "positive_zero", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0155555404000007fc00000800000003f80000041200000", + "classes": [ + "finite", + "finite", + "nan", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0400000404000007fc00000800000003f80000041100000", + "classes": [ + "finite", + "finite", + "nan", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "40000000800000007fc0000000000000000000003dcccccb", + "classes": [ + "finite", + "negative_zero", + "nan", + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c3ab8000beaaaaab3f800000000000003f4b59183f800000", + "classes": [ + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float32-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0e00000c040000000000000800000003dcccccd3f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float32-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "40e00000404000008000000000000000bdcccccdbf800000", + "classes": [ + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float32-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "40e000004040000000000000000000003dcccccd3f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float32-invert", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float32-1", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0c00000c00000003f8000003f8000003f8ccccd40000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float32-128", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "42f2000042fa000043000000430000004300199a43010000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float32-negative-1", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1000000c0800000bf800000bf800000bf66666600000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float32-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0d00000c02000003f0000003f0000003f19999a3fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-add", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c010000000000000c010000000000000000000000000000040000000000000003fc999999999999a3ff199999999999a", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c024000000000000c0000000000000000000000000000000c00000000000000000000000000000003feccccccccccccd", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0350000000000004008000000000000000000000000000080000000000000003f847ae147ae147c3fb999999999999a", + "classes": [ + "finite", + "finite", + "positive_zero", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c002aaaaaaaaaaab40080000000000007ff800000000000080000000000000003ff00000000000004024000000000000", + "classes": [ + "finite", + "finite", + "nan", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c00800000000000040080000000000007ff800000000000080000000000000003ff00000000000004022000000000000", + "classes": [ + "finite", + "finite", + "nan", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "400000000000000080000000000000007ff8000000000000000000000000000000000000000000003fb9999999999996", + "classes": [ + "finite", + "negative_zero", + "nan", + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c075700000000000bfd55555555555553ff000000000000000000000000000003fe96b230bcdc4343ff0000000000000", + "classes": [ + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float64-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c01c000000000000c008000000000000000000000000000080000000000000003fb999999999999a3ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float64-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "401c000000000000400800000000000080000000000000000000000000000000bfb999999999999abff0000000000000", + "classes": [ + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float64-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "401c0000000000004008000000000000000000000000000000000000000000003fb999999999999a3ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float64-invert", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float64-1", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c018000000000000c0000000000000003ff00000000000003ff00000000000003ff199999999999a4000000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float64-128", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "405e400000000000405f4000000000004060000000000000406000000000000040600333333333334060200000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float64-negative-1", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c020000000000000c010000000000000bff0000000000000bff0000000000000bfeccccccccccccd0000000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float64-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c01a000000000000c0040000000000003fe00000000000003fe00000000000003fe33333333333333ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-bool-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-bool-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int8-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int16-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint8-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint16-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-float32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int8-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int16-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-float32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int16-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-float32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int16-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint8-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint16-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-float32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint16-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-float32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-float32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c300000042fe0000000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c300000042fe0000000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c060000000000000405fc0000000000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c060000000000000405fc0000000000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c700000046fffe00000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c700000046fffe00000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c0e000000000000040dfffc00000000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c0e000000000000040dfffc00000000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "cf0000004f000000000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "cf0000004f000000000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c1e000000000000041dfffffffc0000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c1e000000000000041dfffffffc0000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "df0000005f000000000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "df0000005f000000000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043e000000000000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043e000000000000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000437f0000000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000437f0000000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000406fe0000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000406fe0000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000477fff00000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000477fff00000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040efffe00000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040efffe00000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000004f800000000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000004f800000000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000041efffffffe0000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000041efffffffe0000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000005f800000000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000005f800000000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000043f000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000043f000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "0100000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ff0000017f" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffff000000000001007f" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000000000000000000010000007f" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff000000000000000000000000000000000000000000000001000000000000007f" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bff3333380000000000000003ff3333342ffcccd", + "classes": [ + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bffe666660000000800000000000000000000000000000003ffe666660000000405ff999a0000000", + "classes": [ + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-int8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-int16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-int32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-int64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "0100000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ff0000017f" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffff000000000001007f" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000000000000000000010000007f" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff000000000000000000000000000000000000000000000001000000000000007f" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bff3333380000000000000003ff3333342ffcccd", + "classes": [ + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bffe666666666666800000000000000000000000000000003ffe666666666666405ff9999999999a", + "classes": [ + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-int8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-int16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-int32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-int64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "intermediate-not-output-driven", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7f0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fff04000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff0000040000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff00000000000004000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff04000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000040000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000004000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "comparison-rounded-int64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "00" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "comparison-rounded-uint64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "00" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-int8-weak-int", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010203" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-int8-weak-float", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-int8-typed-int", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000020000000000000003" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-int8-typed-float", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-int8-typed-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f0000003fc0000040200000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float32-weak-int", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040400000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float32-weak-float", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f0000003fc0000040200000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float32-typed-int", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004008000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float32-typed-float", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float32-typed-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f0000003fc0000040200000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float64-weak-int", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004008000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float64-weak-float", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float64-typed-int", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004008000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float64-typed-float", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float64-typed-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "noncontracting-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "00000000", + "classes": [ + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-divmod-float32-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "41100000c1200000426c0000c27000007fc000007fc00000800000008000000000000000bf800000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "nan", + "nan", + "negative_zero", + "negative_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-divmod-float32-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "3dcccccb328000003dccccc133c000007fc000007fc000008000000000000000404000007f800000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "nan", + "nan", + "negative_zero", + "positive_zero", + "finite", + "positive_inf" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "noncontracting-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-divmod-float64-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "4022000000000000c024000000000000404d800000000000c04e0000000000007ff80000000000007ff8000000000000800000000000000080000000000000000000000000000000bff0000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "nan", + "nan", + "negative_zero", + "negative_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-divmod-float64-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "3fb99999999999963c900000000000003fb99999999999823cb80000000000007ff80000000000007ff80000000000008000000000000000000000000000000040080000000000007ff0000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "nan", + "nan", + "negative_zero", + "positive_zero", + "finite", + "positive_inf" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + } + ] + }, + "on": { + "native": [ + { + "id": "promotion-bool-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "compare-bool-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-bool-subtract", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "mixed-bool-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "mixed-bool-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "mixed-bool-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "mixed-bool-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "compare-bool-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + } + }, + { + "id": "mixed-bool-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "mixed-bool-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "mixed-bool-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "mixed-bool-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "mixed-bool-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-bool-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-bool-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-bool-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-bool-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-bool-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-bool-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-bool-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-bool-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-bool-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-bool-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-bool-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-bool-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-bool-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-bool-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-bool-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-bool-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-bool-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-bool-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-bool-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-bool-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-bool-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-bool-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-bool-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-bool-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-bool-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-bool-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-bool-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-bool-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-bool-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-bool-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-bool-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-bool-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-bool-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "compare-bool-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + } + }, + { + "id": "mixed-bool-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "mixed-bool-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "mixed-bool-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "mixed-bool-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "mixed-bool-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-bool-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-bool-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-bool-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-bool-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-bool-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-bool-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-bool-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-bool-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-bool-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-bool-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-bool-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-bool-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-bool-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-bool-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-bool-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-bool-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-bool-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-bool-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-bool-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-bool-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-bool-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-bool-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-bool-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-bool-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-bool-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-bool-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-bool-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-bool-uint64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-bool-uint64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-bool-uint64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-bool-uint64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-bool-uint64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-bool-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-bool-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-bool-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-bool-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-bool-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-bool-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-bool-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-bool-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-bool-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-bool-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-bool-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-bool-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-bool-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-bool-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-bool-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-bool-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-bool-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-bool-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-bool-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "compare-int8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + } + }, + { + "id": "mixed-int8-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "mixed-int8-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "mixed-int8-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "mixed-int8-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "mixed-int8-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "compare-int8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + } + }, + { + "id": "mixed-int8-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "mixed-int8-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "mixed-int8-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "mixed-int8-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "mixed-int8-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-int8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-int8-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int8-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int8-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-int8-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-int8-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int8-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-int8-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-int8-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-int8-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-int8-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int8-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int8-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int8-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int8-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int8-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int8-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int8-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int8-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int8-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int8-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int8-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int8-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int8-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int8-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int8-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int8-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int8-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int8-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int8-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int8-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-int8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-int8-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int8-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int8-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-int8-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-int8-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int8-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-int8-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-int8-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-int8-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-int8-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int8-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int8-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int8-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int8-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int8-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int8-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int8-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int8-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int8-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int8-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int8-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int8-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int8-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int8-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int8-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int8-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int8-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int8-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int8-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int8-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int8-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int8-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-int8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-int8-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-int8-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-int8-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-int8-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-int8-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-int8-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int8-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int8-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int8-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int8-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int8-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int8-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int8-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int8-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int8-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-int16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-int16-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-int16-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-int16-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-int16-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-int16-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-int16-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-int16-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-int16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-int16-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-int16-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-int16-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-int16-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-int16-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-int16-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-int16-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-int16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-int16-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-int16-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-int16-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-int16-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-int16-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-int16-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-int16-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int16-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int16-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int16-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int16-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int16-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int16-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int16-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int16-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int16-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int16-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int16-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int16-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int16-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int16-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int16-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int16-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int16-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int16-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int16-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int16-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-int16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-int16-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-int16-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-int16-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-int16-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-int16-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-int16-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-int16-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-int16-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int16-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int16-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int16-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int16-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int16-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int16-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int16-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int16-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int16-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int16-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int16-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int16-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int16-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int16-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int16-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int16-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int16-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int16-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int16-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int16-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int16-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int16-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-int16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-int16-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-int16-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-int16-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-int16-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-int16-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-int16-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int16-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int16-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int16-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int16-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int16-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int16-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int16-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int16-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int16-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int32-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int32-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int32-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int32-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int32-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int32-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int32-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int32-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int32-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int32-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int32-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int32-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int32-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int32-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int32-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int32-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int32-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int32-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int32-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int32-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int32-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int32-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int32-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int32-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int32-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int32-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int32-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int32-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int32-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int32-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int32-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int32-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int32-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int32-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int32-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int32-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int32-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int32-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int32-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int32-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int32-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int32-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int32-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int32-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int32-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-int32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-int32-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-int32-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-int32-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-int32-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-int32-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-int32-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-int32-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int32-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int32-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int32-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int32-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int32-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int32-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int32-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int32-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int32-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int32-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int32-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int32-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int32-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int32-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int32-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int32-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int32-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int32-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int32-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int32-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int32-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-int64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-int64-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-int64-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-int64-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-int64-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-int64-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int64-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int64-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int64-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int64-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-int64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-int64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-int64-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-int64-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-int64-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-int64-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-int64-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-int64-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-int64-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-int64-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-int64-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "compare-uint8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + } + }, + { + "id": "mixed-uint8-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "mixed-uint8-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "mixed-uint8-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "mixed-uint8-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "mixed-uint8-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-uint8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-uint8-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-uint8-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-uint8-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-uint8-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-uint8-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-uint8-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-uint8-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-uint8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-uint8-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-uint8-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-uint8-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-uint8-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-uint8-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-uint8-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-uint8-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint8-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint8-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint8-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint8-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint8-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint8-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint8-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint8-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint8-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint8-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint8-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint8-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint8-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint8-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint8-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint8-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint8-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint8-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint8-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint8-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "compare-uint8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + } + }, + { + "id": "mixed-uint8-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "mixed-uint8-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "mixed-uint8-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "mixed-uint8-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "mixed-uint8-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-uint8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-uint8-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-uint8-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-uint8-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint8-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-uint8-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-uint8-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-uint8-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-uint8-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint8-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint8-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint8-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint8-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint8-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint8-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint8-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint8-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint8-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint8-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint8-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint8-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint8-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint8-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint8-uint64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint8-uint64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint8-uint64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint8-uint64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint8-uint64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint8-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-uint8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-uint8-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-uint8-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-uint8-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-uint8-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-uint8-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-uint8-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint8-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint8-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint8-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint8-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint8-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint8-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint8-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint8-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint8-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-uint16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-uint16-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-uint16-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-uint16-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-uint16-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-uint16-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-uint16-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-uint16-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint16-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint16-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint16-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint16-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint16-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint16-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint16-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint16-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint16-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint16-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint16-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint16-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint16-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint16-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint16-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint16-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint16-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint16-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint16-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint16-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint16-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint16-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint16-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint16-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint16-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint16-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint16-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint16-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint16-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-uint16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-uint16-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-uint16-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-uint16-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-uint16-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-uint16-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-uint16-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-uint16-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "compare-uint16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + } + }, + { + "id": "mixed-uint16-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "mixed-uint16-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "mixed-uint16-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "mixed-uint16-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + } + }, + { + "id": "mixed-uint16-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "mixed-uint16-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "mixed-uint16-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "mixed-uint16-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint16-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint16-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint16-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint16-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint16-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint16-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint16-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint16-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint16-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint16-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint16-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint16-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint16-uint64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint16-uint64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint16-uint64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint16-uint64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint16-uint64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint16-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-uint16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-uint16-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-uint16-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-uint16-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-uint16-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-uint16-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-uint16-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint16-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint16-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint16-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint16-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint16-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint16-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint16-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint16-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint16-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint32-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint32-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint32-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint32-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint32-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint32-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint32-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint32-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint32-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint32-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint32-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint32-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint32-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint32-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint32-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint32-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint32-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint32-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint32-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint32-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint32-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint32-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint32-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint32-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint32-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "compare-uint32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + } + }, + { + "id": "mixed-uint32-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "mixed-uint32-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "mixed-uint32-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + } + }, + { + "id": "mixed-uint32-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + } + }, + { + "id": "mixed-uint32-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "mixed-uint32-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + } + }, + { + "id": "mixed-uint32-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-uint64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint32-uint64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint32-uint64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-uint64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint32-uint64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint32-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint32-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint32-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint32-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint32-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint32-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint32-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint32-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint32-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint64-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-int64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint64-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint64-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint64-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "compare-uint64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + } + }, + { + "id": "mixed-uint64-uint64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + } + }, + { + "id": "mixed-uint64-uint64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "mixed-uint64-uint64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + } + }, + { + "id": "mixed-uint64-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-uint64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-uint64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-uint64-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-uint64-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-uint64-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-uint64-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-uint64-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-uint64-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-uint64-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-uint64-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-float32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-float32-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-float32-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-float32-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-float32-bool-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-bool-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-bool-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-bool-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-bool-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-float32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-float32-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-float32-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-float32-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-float32-int8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-float32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-float32-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-float32-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-float32-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-float32-int16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float32-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float32-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float32-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float32-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-int64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-float32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-float32-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-float32-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-float32-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-float32-uint8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-float32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-float32-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-float32-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-float32-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-float32-uint16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float32-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float32-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float32-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float32-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "compare-float32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000" + } + }, + { + "id": "mixed-float32-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000" + } + }, + { + "id": "mixed-float32-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000" + } + }, + { + "id": "mixed-float32-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000" + } + }, + { + "id": "mixed-float32-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "mixed-float32-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float32-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float32-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float32-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float32-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float32-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float32-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float32-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float32-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float32-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-bool-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-bool-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-bool-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-bool-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-bool-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-bool-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-int64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-int64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 30, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "promotion-float64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "compare-float64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "mixed-float64-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000" + } + }, + { + "id": "mixed-float64-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000" + } + }, + { + "id": "mixed-float64-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "mixed-float64-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "mixed-float64-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "mixed-float64-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "mixed-float64-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "mixed-float64-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "mixed-float64-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "operator-bool-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "operator-bool-subtract", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-bool-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "operator-bool-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000000000000000000007ff0000000000000" + } + }, + { + "id": "operator-bool-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "operator-bool-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "operator-bool-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "operator-bool-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "operator-bool-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "operator-bool-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "operator-bool-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "020001" + } + }, + { + "id": "operator-bool-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "operator-bool-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + } + }, + { + "id": "operator-bool-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "operator-bool-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "operator-bool-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + } + }, + { + "id": "operator-bool-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + } + }, + { + "id": "operator-bool-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "unary-bool-positive", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "unary-bool-negative", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "unary-bool-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "unary-bool-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "weak-bool-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000200000000000000010000000000000002" + } + }, + { + "id": "weak-compare-bool-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + } + }, + { + "id": "weak-compare-bool-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "weak-bool-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000008100000000000000800000000000000081" + } + }, + { + "id": "weak-compare-bool-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "weak-compare-bool-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "weak-bool-negative-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff0000000000000000" + } + }, + { + "id": "weak-compare-bool-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "weak-compare-bool-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "weak-bool-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff80000000000003fe00000000000003ff8000000000000" + } + }, + { + "id": "weak-compare-bool-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "weak-compare-bool-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + } + }, + { + "id": "operator-int8-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "81810001fcfc" + } + }, + { + "id": "operator-int8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7f7d0001f6fe" + } + }, + { + "id": "operator-int8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80fe0000eb03" + } + }, + { + "id": "operator-int8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c060000000000000404fc000000000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000" + } + }, + { + "id": "operator-int8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "803f0000fd03" + } + }, + { + "id": "operator-int8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100000200" + } + }, + { + "id": "operator-int8-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-int8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0002000001fd" + } + }, + { + "id": "operator-int8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "817f0001fbff" + } + }, + { + "id": "operator-int8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "817d0001fa02" + } + }, + { + "id": "operator-int8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fc0001c800" + } + }, + { + "id": "operator-int8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c01f0001ffff" + } + }, + { + "id": "operator-int8-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + } + }, + { + "id": "operator-int8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "operator-int8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + } + }, + { + "id": "operator-int8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-int8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-int8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + } + }, + { + "id": "unary-int8-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "807f0001f9fd" + } + }, + { + "id": "unary-int8-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "808100ff0703" + } + }, + { + "id": "unary-int8-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "807f00010703" + } + }, + { + "id": "unary-int8-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7f80fffe0602" + } + }, + { + "id": "integer-divisor-boundary-int8-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000" + } + }, + { + "id": "integer-divisor-boundary-int8-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "shift-boundary-int8-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80fe00000000" + } + }, + { + "id": "shift-boundary-int8-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "803f0000ffff" + } + }, + { + "id": "weak-int8-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "81800102fafe" + } + }, + { + "id": "weak-compare-int8-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-int8-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "weak-int8-128", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "weak-compare-int8-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int8-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010101" + } + }, + { + "id": "weak-int8-negative-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7f7eff00f8fc" + } + }, + { + "id": "weak-compare-int8-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int8-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "weak-int8-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c05fe00000000000405fe000000000003fe00000000000003ff8000000000000c01a000000000000c004000000000000" + } + }, + { + "id": "weak-compare-int8-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int8-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-int16-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8001800100000001fffcfffc" + } + }, + { + "id": "operator-int16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fff7ffd00000001fff6fffe" + } + }, + { + "id": "operator-int16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000fffe00000000ffeb0003" + } + }, + { + "id": "operator-int16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0e000000000000040cfffc0000000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000" + } + }, + { + "id": "operator-int16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80003fff00000000fffd0003" + } + }, + { + "id": "operator-int16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000000020000" + } + }, + { + "id": "operator-int16-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-int16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000002000000000001fffd" + } + }, + { + "id": "operator-int16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80017fff00000001fffbffff" + } + }, + { + "id": "operator-int16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80017ffd00000001fffa0002" + } + }, + { + "id": "operator-int16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffc00000001ffc80000" + } + }, + { + "id": "operator-int16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0001fff00000001ffffffff" + } + }, + { + "id": "operator-int16-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + } + }, + { + "id": "operator-int16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "operator-int16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + } + }, + { + "id": "operator-int16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-int16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-int16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + } + }, + { + "id": "unary-int16-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001fff9fffd" + } + }, + { + "id": "unary-int16-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800080010000ffff00070003" + } + }, + { + "id": "unary-int16-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80007fff0000000100070003" + } + }, + { + "id": "unary-int16-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fff8000fffffffe00060002" + } + }, + { + "id": "integer-divisor-boundary-int16-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000000000" + } + }, + { + "id": "integer-divisor-boundary-int16-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "shift-boundary-int16-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000fffe0000000000000000" + } + }, + { + "id": "shift-boundary-int16-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80003fff00000000ffffffff" + } + }, + { + "id": "weak-int16-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8001800000010002fffafffe" + } + }, + { + "id": "weak-compare-int16-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-int16-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "weak-int16-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8080807f008000810079007d" + } + }, + { + "id": "weak-compare-int16-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int16-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + } + }, + { + "id": "weak-int16-negative-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fff7ffeffff0000fff8fffc" + } + }, + { + "id": "weak-compare-int16-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int16-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "weak-int16-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0dfffe00000000040dfffe0000000003fe00000000000003ff8000000000000c01a000000000000c004000000000000" + } + }, + { + "id": "weak-compare-int16-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int16-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-int32-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000001800000010000000000000001fffffffcfffffffc" + } + }, + { + "id": "operator-int32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff7ffffffd0000000000000001fffffff6fffffffe" + } + }, + { + "id": "operator-int32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000fffffffe0000000000000000ffffffeb00000003" + } + }, + { + "id": "operator-int32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1e000000000000041cfffffffc000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000" + } + }, + { + "id": "operator-int32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000003fffffff0000000000000000fffffffd00000003" + } + }, + { + "id": "operator-int32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000000000000200000000" + } + }, + { + "id": "operator-int32-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-int32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000002000000000000000000000001fffffffd" + } + }, + { + "id": "operator-int32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000017fffffff0000000000000001fffffffbffffffff" + } + }, + { + "id": "operator-int32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000017ffffffd0000000000000001fffffffa00000002" + } + }, + { + "id": "operator-int32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffc0000000000000001ffffffc800000000" + } + }, + { + "id": "operator-int32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c00000001fffffff0000000000000001ffffffffffffffff" + } + }, + { + "id": "operator-int32-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + } + }, + { + "id": "operator-int32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "operator-int32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + } + }, + { + "id": "operator-int32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-int32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-int32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + } + }, + { + "id": "unary-int32-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001fffffff9fffffffd" + } + }, + { + "id": "unary-int32-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000008000000100000000ffffffff0000000700000003" + } + }, + { + "id": "unary-int32-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff00000000000000010000000700000003" + } + }, + { + "id": "unary-int32-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff80000000fffffffffffffffe0000000600000002" + } + }, + { + "id": "integer-divisor-boundary-int32-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000000000000000000000" + } + }, + { + "id": "integer-divisor-boundary-int32-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "shift-boundary-int32-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000fffffffe00000000000000000000000000000000" + } + }, + { + "id": "shift-boundary-int32-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000003fffffff0000000000000000ffffffffffffffff" + } + }, + { + "id": "weak-int32-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000001800000000000000100000002fffffffafffffffe" + } + }, + { + "id": "weak-compare-int32-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-int32-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "weak-int32-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000808000007f0000008000000081000000790000007d" + } + }, + { + "id": "weak-compare-int32-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int32-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + } + }, + { + "id": "weak-int32-negative-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff7ffffffeffffffff00000000fffffff8fffffffc" + } + }, + { + "id": "weak-compare-int32-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int32-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "weak-int32-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1dfffffffe0000041dfffffffe000003fe00000000000003ff8000000000000c01a000000000000c004000000000000" + } + }, + { + "id": "weak-compare-int32-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int32-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-int64-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000001800000000000000100000000000000000000000000000001fffffffffffffffcfffffffffffffffc" + } + }, + { + "id": "operator-int64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff7ffffffffffffffd00000000000000000000000000000001fffffffffffffff6fffffffffffffffe" + } + }, + { + "id": "operator-int64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000000fffffffffffffffe00000000000000000000000000000000ffffffffffffffeb0000000000000003" + } + }, + { + "id": "operator-int64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043d00000000000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000" + } + }, + { + "id": "operator-int64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000003fffffffffffffff00000000000000000000000000000000fffffffffffffffd0000000000000003" + } + }, + { + "id": "operator-int64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000000000000000000000000000000000020000000000000000" + } + }, + { + "id": "operator-int64-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-int64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000002000000000000000000000000000000000000000000000001fffffffffffffffd" + } + }, + { + "id": "operator-int64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000017fffffffffffffff00000000000000000000000000000001fffffffffffffffbffffffffffffffff" + } + }, + { + "id": "operator-int64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000017ffffffffffffffd00000000000000000000000000000001fffffffffffffffa0000000000000002" + } + }, + { + "id": "operator-int64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffc00000000000000000000000000000001ffffffffffffffc80000000000000000" + } + }, + { + "id": "operator-int64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0000000000000001fffffffffffffff00000000000000000000000000000001ffffffffffffffffffffffffffffffff" + } + }, + { + "id": "operator-int64-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + } + }, + { + "id": "operator-int64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "operator-int64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + } + }, + { + "id": "operator-int64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-int64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-int64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + } + }, + { + "id": "unary-int64-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001fffffffffffffff9fffffffffffffffd" + } + }, + { + "id": "unary-int64-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000000000000080000000000000010000000000000000ffffffffffffffff00000000000000070000000000000003" + } + }, + { + "id": "unary-int64-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff0000000000000000000000000000000100000000000000070000000000000003" + } + }, + { + "id": "unary-int64-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff8000000000000000fffffffffffffffffffffffffffffffe00000000000000060000000000000002" + } + }, + { + "id": "integer-divisor-boundary-int64-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000000000000000000000000000000000000000000000" + } + }, + { + "id": "integer-divisor-boundary-int64-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "shift-boundary-int64-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000000fffffffffffffffe0000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "id": "shift-boundary-int64-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000003fffffffffffffff00000000000000000000000000000000ffffffffffffffffffffffffffffffff" + } + }, + { + "id": "weak-int64-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000001800000000000000000000000000000010000000000000002fffffffffffffffafffffffffffffffe" + } + }, + { + "id": "weak-compare-int64-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-int64-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "weak-int64-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000080800000000000007f000000000000008000000000000000810000000000000079000000000000007d" + } + }, + { + "id": "weak-compare-int64-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int64-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + } + }, + { + "id": "weak-int64-negative-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff7ffffffffffffffeffffffffffffffff0000000000000000fffffffffffffff8fffffffffffffffc" + } + }, + { + "id": "weak-compare-int64-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int64-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + } + }, + { + "id": "weak-int64-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043e00000000000003fe00000000000003ff8000000000000c01a000000000000c004000000000000" + } + }, + { + "id": "weak-compare-int64-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-int64-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-uint8-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010406" + } + }, + { + "id": "operator-uint8-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffd00010000" + } + }, + { + "id": "operator-uint8-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fe00000409" + } + }, + { + "id": "operator-uint8-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000405fe000000000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "operator-uint8-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "007f00000101" + } + }, + { + "id": "operator-uint8-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100000000" + } + }, + { + "id": "operator-uint8-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00010101041b" + } + }, + { + "id": "operator-uint8-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000200000203" + } + }, + { + "id": "operator-uint8-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "01ff00010203" + } + }, + { + "id": "operator-uint8-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "01fd00010000" + } + }, + { + "id": "operator-uint8-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fc00010818" + } + }, + { + "id": "operator-uint8-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "003f00010000" + } + }, + { + "id": "operator-uint8-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + } + }, + { + "id": "operator-uint8-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + } + }, + { + "id": "operator-uint8-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + } + }, + { + "id": "operator-uint8-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-uint8-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-uint8-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + } + }, + { + "id": "unary-uint8-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00ff00010203" + } + }, + { + "id": "unary-uint8-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100fffefd" + } + }, + { + "id": "unary-uint8-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00ff00010203" + } + }, + { + "id": "unary-uint8-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ff00fffefdfc" + } + }, + { + "id": "integer-divisor-boundary-uint8-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "integer-divisor-boundary-uint8-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "shift-boundary-uint8-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fe00000000" + } + }, + { + "id": "shift-boundary-uint8-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "007f00000000" + } + }, + { + "id": "weak-uint8-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001020304" + } + }, + { + "id": "weak-compare-uint8-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-uint8-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "weak-uint8-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "807f80818283" + } + }, + { + "id": "weak-compare-uint8-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint8-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + } + }, + { + "id": "weak-uint8-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "weak-compare-uint8-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint8-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-uint8-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe0000000000000406ff000000000003fe00000000000003ff80000000000004004000000000000400c000000000000" + } + }, + { + "id": "weak-compare-uint8-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint8-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "operator-uint16-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000000100040006" + } + }, + { + "id": "operator-uint16-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffffffd0000000100000000" + } + }, + { + "id": "operator-uint16-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffe0000000000040009" + } + }, + { + "id": "operator-uint16-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040dfffe0000000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "operator-uint16-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00007fff0000000000010001" + } + }, + { + "id": "operator-uint16-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000000000000" + } + }, + { + "id": "operator-uint16-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000001000100010004001b" + } + }, + { + "id": "operator-uint16-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000020000000000020003" + } + }, + { + "id": "operator-uint16-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0001ffff0000000100020003" + } + }, + { + "id": "operator-uint16-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0001fffd0000000100000000" + } + }, + { + "id": "operator-uint16-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffc0000000100080018" + } + }, + { + "id": "operator-uint16-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00003fff0000000100000000" + } + }, + { + "id": "operator-uint16-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + } + }, + { + "id": "operator-uint16-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + } + }, + { + "id": "operator-uint16-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + } + }, + { + "id": "operator-uint16-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-uint16-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-uint16-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + } + }, + { + "id": "unary-uint16-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff0000000100020003" + } + }, + { + "id": "unary-uint16-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000fffffffefffd" + } + }, + { + "id": "unary-uint16-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff0000000100020003" + } + }, + { + "id": "unary-uint16-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ffff0000fffffffefffdfffc" + } + }, + { + "id": "integer-divisor-boundary-uint16-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "integer-divisor-boundary-uint16-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "shift-boundary-uint16-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffe0000000000000000" + } + }, + { + "id": "shift-boundary-uint16-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00007fff0000000000000000" + } + }, + { + "id": "weak-uint16-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100000001000200030004" + } + }, + { + "id": "weak-compare-uint16-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-uint16-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "weak-uint16-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0080007f0080008100820083" + } + }, + { + "id": "weak-compare-uint16-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint16-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + } + }, + { + "id": "weak-uint16-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "weak-compare-uint16-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint16-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-uint16-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe000000000000040effff0000000003fe00000000000003ff80000000000004004000000000000400c000000000000" + } + }, + { + "id": "weak-compare-uint16-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint16-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "operator-uint32-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000000000010000000400000006" + } + }, + { + "id": "operator-uint32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffffffffffffffd00000000000000010000000000000000" + } + }, + { + "id": "operator-uint32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffe00000000000000000000000400000009" + } + }, + { + "id": "operator-uint32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000041dfffffffe000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "operator-uint32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000007fffffff00000000000000000000000100000001" + } + }, + { + "id": "operator-uint32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000000000000000000000" + } + }, + { + "id": "operator-uint32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000100000001000000040000001b" + } + }, + { + "id": "operator-uint32-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000200000000000000000000000200000003" + } + }, + { + "id": "operator-uint32-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000001ffffffff00000000000000010000000200000003" + } + }, + { + "id": "operator-uint32-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000001fffffffd00000000000000010000000000000000" + } + }, + { + "id": "operator-uint32-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffc00000000000000010000000800000018" + } + }, + { + "id": "operator-uint32-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000003fffffff00000000000000010000000000000000" + } + }, + { + "id": "operator-uint32-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + } + }, + { + "id": "operator-uint32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + } + }, + { + "id": "operator-uint32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + } + }, + { + "id": "operator-uint32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-uint32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-uint32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + } + }, + { + "id": "unary-uint32-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff00000000000000010000000200000003" + } + }, + { + "id": "unary-uint32-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000fffffffffffffffefffffffd" + } + }, + { + "id": "unary-uint32-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff00000000000000010000000200000003" + } + }, + { + "id": "unary-uint32-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff00000000fffffffffffffffefffffffdfffffffc" + } + }, + { + "id": "integer-divisor-boundary-uint32-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "integer-divisor-boundary-uint32-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "shift-boundary-uint32-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffe00000000000000000000000000000000" + } + }, + { + "id": "shift-boundary-uint32-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000007fffffff00000000000000000000000000000000" + } + }, + { + "id": "weak-uint32-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000000000001000000020000000300000004" + } + }, + { + "id": "weak-compare-uint32-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-uint32-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "weak-uint32-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000800000007f00000080000000810000008200000083" + } + }, + { + "id": "weak-compare-uint32-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint32-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + } + }, + { + "id": "weak-uint32-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "weak-compare-uint32-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint32-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-uint32-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe000000000000041effffffff000003fe00000000000003ff80000000000004004000000000000400c000000000000" + } + }, + { + "id": "weak-compare-uint32-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint32-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "operator-uint64-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000000000000000000100000000000000040000000000000006" + } + }, + { + "id": "operator-uint64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffffffffffffffffffffffffffffffd0000000000000000000000000000000100000000000000000000000000000000" + } + }, + { + "id": "operator-uint64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffe0000000000000000000000000000000000000000000000040000000000000009" + } + }, + { + "id": "operator-uint64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000043e00000000000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "operator-uint64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007fffffffffffffff0000000000000000000000000000000000000000000000010000000000000001" + } + }, + { + "id": "operator-uint64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "id": "operator-uint64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001000000000000000100000000000000010000000000000004000000000000001b" + } + }, + { + "id": "operator-uint64-bit-and", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000020000000000000000000000000000000000000000000000020000000000000003" + } + }, + { + "id": "operator-uint64-bit-or", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001ffffffffffffffff0000000000000000000000000000000100000000000000020000000000000003" + } + }, + { + "id": "operator-uint64-bit-xor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001fffffffffffffffd0000000000000000000000000000000100000000000000000000000000000000" + } + }, + { + "id": "operator-uint64-shift-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffc0000000000000000000000000000000100000000000000080000000000000018" + } + }, + { + "id": "operator-uint64-shift-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fffffffffffffff0000000000000000000000000000000100000000000000000000000000000000" + } + }, + { + "id": "operator-uint64-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + } + }, + { + "id": "operator-uint64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + } + }, + { + "id": "operator-uint64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + } + }, + { + "id": "operator-uint64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + } + }, + { + "id": "operator-uint64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + } + }, + { + "id": "operator-uint64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + } + }, + { + "id": "unary-uint64-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff0000000000000000000000000000000100000000000000020000000000000003" + } + }, + { + "id": "unary-uint64-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000fffffffffffffffffffffffffffffffefffffffffffffffd" + } + }, + { + "id": "unary-uint64-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff0000000000000000000000000000000100000000000000020000000000000003" + } + }, + { + "id": "unary-uint64-invert", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff0000000000000000fffffffffffffffffffffffffffffffefffffffffffffffdfffffffffffffffc" + } + }, + { + "id": "integer-divisor-boundary-uint64-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "integer-divisor-boundary-uint64-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "shift-boundary-uint64-left", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffe0000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "id": "shift-boundary-uint64-right", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007fffffffffffffff0000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "id": "weak-uint64-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000000000000000000001000000000000000200000000000000030000000000000004" + } + }, + { + "id": "weak-compare-uint64-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + } + }, + { + "id": "weak-compare-uint64-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "weak-uint64-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000080000000000000007f0000000000000080000000000000008100000000000000820000000000000083" + } + }, + { + "id": "weak-compare-uint64-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint64-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + } + }, + { + "id": "weak-uint64-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "weak-compare-uint64-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint64-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-uint64-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe000000000000043f00000000000003fe00000000000003ff80000000000004004000000000000400c000000000000" + } + }, + { + "id": "weak-compare-uint64-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-uint64-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + } + }, + { + "id": "operator-float32-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0800000c080000000000000400000003e4ccccd3f8ccccd" + } + }, + { + "id": "operator-float32-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1200000c000000000000000c0000000000000003f666666" + } + }, + { + "id": "operator-float32-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1a800004040000000000000800000003c23d70b3dcccccd" + } + }, + { + "id": "operator-float32-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0155555404000007fc00000800000003f80000041200000" + } + }, + { + "id": "operator-float32-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0400000404000007fc00000800000003f80000041100000" + } + }, + { + "id": "operator-float32-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "40000000800000007fc0000000000000000000003dcccccb" + } + }, + { + "id": "operator-float32-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c3ab8000beaaaaab3f800000000000003f4b59183f800000" + } + }, + { + "id": "operator-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float32-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000100" + } + }, + { + "id": "operator-float32-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + } + }, + { + "id": "operator-float32-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010001" + } + }, + { + "id": "operator-float32-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + } + }, + { + "id": "operator-float32-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "operator-float32-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + } + }, + { + "id": "unary-float32-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0e00000c040000000000000800000003dcccccd3f800000" + } + }, + { + "id": "unary-float32-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "40e00000404000008000000000000000bdcccccdbf800000" + } + }, + { + "id": "unary-float32-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "40e000004040000000000000000000003dcccccd3f800000" + } + }, + { + "id": "unary-float32-invert", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "weak-float32-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0c00000c00000003f8000003f8000003f8ccccd40000000" + } + }, + { + "id": "weak-compare-float32-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "weak-compare-float32-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + } + }, + { + "id": "weak-float32-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "42f2000042fa000043000000430000004300199a43010000" + } + }, + { + "id": "weak-compare-float32-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-float32-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010101" + } + }, + { + "id": "weak-float32-negative-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1000000c0800000bf800000bf800000bf66666600000000" + } + }, + { + "id": "weak-compare-float32-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-float32-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100000000" + } + }, + { + "id": "weak-float32-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0d00000c02000003f0000003f0000003f19999a3fc00000" + } + }, + { + "id": "weak-compare-float32-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-float32-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + } + }, + { + "id": "operator-float64-add", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c010000000000000c010000000000000000000000000000040000000000000003fc999999999999a3ff199999999999a" + } + }, + { + "id": "operator-float64-subtract", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c024000000000000c0000000000000000000000000000000c00000000000000000000000000000003feccccccccccccd" + } + }, + { + "id": "operator-float64-multiply", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0350000000000004008000000000000000000000000000080000000000000003f847ae147ae147c3fb999999999999a" + } + }, + { + "id": "operator-float64-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c002aaaaaaaaaaab40080000000000007ff800000000000080000000000000003ff00000000000004024000000000000" + } + }, + { + "id": "operator-float64-floor-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c00800000000000040080000000000007ff800000000000080000000000000003ff00000000000004022000000000000" + } + }, + { + "id": "operator-float64-remainder", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "400000000000000080000000000000007ff8000000000000000000000000000000000000000000003fb9999999999996" + } + }, + { + "id": "operator-float64-power", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c075700000000000bfd55555555555553ff000000000000000000000000000003fe96b230bcdc4343ff0000000000000" + } + }, + { + "id": "operator-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "operator-float64-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000100" + } + }, + { + "id": "operator-float64-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + } + }, + { + "id": "operator-float64-not-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010001" + } + }, + { + "id": "operator-float64-less-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + } + }, + { + "id": "operator-float64-greater", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "operator-float64-greater-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + } + }, + { + "id": "unary-float64-positive", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c01c000000000000c008000000000000000000000000000080000000000000003fb999999999999a3ff0000000000000" + } + }, + { + "id": "unary-float64-negative", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "401c000000000000400800000000000080000000000000000000000000000000bfb999999999999abff0000000000000" + } + }, + { + "id": "unary-float64-absolute", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "401c0000000000004008000000000000000000000000000000000000000000003fb999999999999a3ff0000000000000" + } + }, + { + "id": "unary-float64-invert", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "weak-float64-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c018000000000000c0000000000000003ff00000000000003ff00000000000003ff199999999999a4000000000000000" + } + }, + { + "id": "weak-compare-float64-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + } + }, + { + "id": "weak-compare-float64-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + } + }, + { + "id": "weak-float64-128", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "405e400000000000405f4000000000004060000000000000406000000000000040600333333333334060200000000000" + } + }, + { + "id": "weak-compare-float64-128-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-float64-128-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010101" + } + }, + { + "id": "weak-float64-negative-1", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c020000000000000c010000000000000bff0000000000000bff0000000000000bfeccccccccccccd0000000000000000" + } + }, + { + "id": "weak-compare-float64-negative-1-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-float64-negative-1-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100000000" + } + }, + { + "id": "weak-float64-0point-5", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c01a000000000000c0040000000000003fe00000000000003fe00000000000003fe33333333333333ff8000000000000" + } + }, + { + "id": "weak-compare-float64-0point-5-equal", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "weak-compare-float64-0point-5-less", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + } + }, + { + "id": "cast-bool-bool-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-bool-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-int8-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-int16-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-bool-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-bool-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-bool-int32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-bool-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-bool-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-bool-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-bool-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-bool-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-bool-uint8-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-uint8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-bool-uint16-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-bool-uint16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-bool-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-bool-uint32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-bool-uint32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-bool-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-bool-uint64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-bool-uint64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-bool-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-bool-float32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-bool-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-bool-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-bool-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-bool-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-bool-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int8-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int8-int8-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int8-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int8-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int8-int16-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int8-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int8-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int8-int32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int8-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int8-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int8-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int8-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int8-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int8-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int8-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int8-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int8-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int8-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int8-float32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int8-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int8-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int8-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int8-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int8-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int16-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int16-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int16-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int16-int16-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int16-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int16-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int16-int32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int16-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int16-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int16-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int16-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int16-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int16-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int16-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int16-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int16-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int16-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int16-float32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int16-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int16-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int16-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int16-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int16-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int32-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int32-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int32-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int32-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int32-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int32-int32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int32-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int32-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int32-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int32-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int32-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int32-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int32-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int32-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int32-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int32-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int32-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int32-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int32-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int32-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int32-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int64-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int64-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int64-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int64-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int64-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int64-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int64-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int64-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int64-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int64-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int64-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-int64-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-int64-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-int64-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-int64-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-int64-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int64-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-int64-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int64-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-int64-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint8-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint8-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint8-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint8-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint8-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint8-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint8-int16-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint8-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint8-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint8-int32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint8-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint8-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint8-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint8-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint8-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint8-uint8-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint8-uint8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint8-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint8-uint16-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint8-uint16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint8-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint8-uint32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint8-uint32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint8-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint8-uint64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint8-uint64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint8-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint8-float32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint8-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint8-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint8-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint8-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint8-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint16-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint16-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint16-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint16-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint16-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint16-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint16-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint16-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint16-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint16-int32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint16-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint16-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint16-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint16-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint16-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint16-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint16-uint8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint16-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint16-uint16-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint16-uint16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint16-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint16-uint32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint16-uint32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint16-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint16-uint64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint16-uint64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint16-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint16-float32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint16-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint16-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint16-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint16-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint16-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint32-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint32-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint32-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint32-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint32-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint32-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint32-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint32-int64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint32-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint32-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint32-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-uint8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint32-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint32-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-uint16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint32-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint32-uint32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint32-uint32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint32-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint32-uint64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint32-uint64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint32-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint32-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint32-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint32-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint32-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint32-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint32-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint64-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint64-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-int8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint64-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint64-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-int16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint64-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint64-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-int32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint64-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint64-int64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-int64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint64-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint64-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-uint8-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint64-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-uint64-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-uint16-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint64-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-uint64-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-uint32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint64-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-uint64-uint64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint64-uint64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint64-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-uint64-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-uint64-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint64-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-uint64-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint64-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-uint64-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-float32-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-float32-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-float32-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-float32-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-float32-int64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-float32-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-float32-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-float32-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-float32-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float32-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-float32-float32-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-float32-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-float32-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-float32-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-float32-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-float32-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-float64-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-bool-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-float64-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-float64-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-float64-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-float64-int64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-int64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-float64-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint8-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + } + }, + { + "id": "cast-float64-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint16-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + } + }, + { + "id": "cast-float64-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + } + }, + { + "id": "cast-float64-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-uint64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + } + }, + { + "id": "cast-float64-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "cast-float64-float32-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-float64-float32-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + } + }, + { + "id": "cast-float64-float64-safe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-float64-float64-same-kind", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-float64-float64-unsafe", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-int8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "explicit-int8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "cast-boundary-int8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + } + }, + { + "id": "explicit-int8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + } + }, + { + "id": "cast-boundary-int8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + } + }, + { + "id": "explicit-int8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + } + }, + { + "id": "cast-boundary-int8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + } + }, + { + "id": "explicit-int8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + } + }, + { + "id": "cast-boundary-int8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + } + }, + { + "id": "explicit-int8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + } + }, + { + "id": "explicit-int8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + } + }, + { + "id": "cast-boundary-int8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + } + }, + { + "id": "explicit-int8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + } + }, + { + "id": "cast-boundary-int8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + } + }, + { + "id": "explicit-int8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + } + }, + { + "id": "cast-boundary-int8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + } + }, + { + "id": "explicit-int8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c300000042fe0000000000003f800000" + } + }, + { + "id": "explicit-int8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c300000042fe0000000000003f800000" + } + }, + { + "id": "cast-boundary-int8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c060000000000000405fc0000000000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-int8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c060000000000000405fc0000000000000000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-int16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "explicit-int16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "cast-boundary-int16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-int16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-int16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + } + }, + { + "id": "explicit-int16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + } + }, + { + "id": "cast-boundary-int16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + } + }, + { + "id": "explicit-int16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + } + }, + { + "id": "cast-boundary-int16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + } + }, + { + "id": "explicit-int16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-int16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-int16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + } + }, + { + "id": "explicit-int16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + } + }, + { + "id": "cast-boundary-int16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + } + }, + { + "id": "explicit-int16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + } + }, + { + "id": "cast-boundary-int16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + } + }, + { + "id": "explicit-int16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c700000046fffe00000000003f800000" + } + }, + { + "id": "explicit-int16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c700000046fffe00000000003f800000" + } + }, + { + "id": "cast-boundary-int16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c0e000000000000040dfffc00000000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-int16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c0e000000000000040dfffc00000000000000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-int32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "explicit-int32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "cast-boundary-int32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-int32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-int32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-int32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-int32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + } + }, + { + "id": "explicit-int32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + } + }, + { + "id": "cast-boundary-int32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-int32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-int32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-int32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-int32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-int32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + } + }, + { + "id": "explicit-int32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + } + }, + { + "id": "cast-boundary-int32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-int32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "cf0000004f000000000000003f800000" + } + }, + { + "id": "explicit-int32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "cf0000004f000000000000003f800000" + } + }, + { + "id": "cast-boundary-int32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c1e000000000000041dfffffffc0000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-int32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c1e000000000000041dfffffffc0000000000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-int64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "explicit-int64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + } + }, + { + "id": "cast-boundary-int64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-int64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-int64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-int64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-int64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "explicit-int64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "cast-boundary-int64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-int64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-int64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-int64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-int64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-int64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "explicit-int64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "cast-boundary-int64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-int64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-int64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "df0000005f000000000000003f800000" + } + }, + { + "id": "explicit-int64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "df0000005f000000000000003f800000" + } + }, + { + "id": "cast-boundary-int64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043e000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-int64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043e000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-uint8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "explicit-uint8-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "cast-boundary-uint8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint8-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + } + }, + { + "id": "explicit-uint8-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + } + }, + { + "id": "cast-boundary-uint8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + } + }, + { + "id": "explicit-uint8-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + } + }, + { + "id": "cast-boundary-uint8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint8-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint8-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + } + }, + { + "id": "explicit-uint8-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + } + }, + { + "id": "cast-boundary-uint8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + } + }, + { + "id": "explicit-uint8-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + } + }, + { + "id": "cast-boundary-uint8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint8-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000437f0000000000003f800000" + } + }, + { + "id": "explicit-uint8-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000437f0000000000003f800000" + } + }, + { + "id": "cast-boundary-uint8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000406fe0000000000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-uint8-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000406fe0000000000000000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-uint16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "explicit-uint16-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "cast-boundary-uint16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint16-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-uint16-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-uint16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + } + }, + { + "id": "explicit-uint16-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + } + }, + { + "id": "cast-boundary-uint16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint16-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint16-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-uint16-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-uint16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + } + }, + { + "id": "explicit-uint16-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + } + }, + { + "id": "cast-boundary-uint16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint16-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000477fff00000000003f800000" + } + }, + { + "id": "explicit-uint16-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000477fff00000000003f800000" + } + }, + { + "id": "cast-boundary-uint16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040efffe00000000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-uint16-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040efffe00000000000000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-uint32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "explicit-uint32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "cast-boundary-uint32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-uint32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-uint32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "explicit-uint32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "cast-boundary-uint32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint32-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-uint32-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-uint32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "explicit-uint32-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "cast-boundary-uint32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint32-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000004f800000000000003f800000" + } + }, + { + "id": "explicit-uint32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000004f800000000000003f800000" + } + }, + { + "id": "cast-boundary-uint32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000041efffffffe0000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-uint32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000041efffffffe0000000000000000000003ff0000000000000" + } + }, + { + "id": "cast-boundary-uint64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "explicit-uint64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "cast-boundary-uint64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-uint64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-uint64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "explicit-uint64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "cast-boundary-uint64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "explicit-uint64-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + } + }, + { + "id": "cast-boundary-uint64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "explicit-uint64-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + } + }, + { + "id": "cast-boundary-uint64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "explicit-uint64-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + } + }, + { + "id": "cast-boundary-uint64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "explicit-uint64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + } + }, + { + "id": "cast-boundary-uint64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000005f800000000000003f800000" + } + }, + { + "id": "explicit-uint64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000005f800000000000003f800000" + } + }, + { + "id": "cast-boundary-uint64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000043f000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "explicit-uint64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000043f000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "float-cast-float32-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "0100000101" + } + }, + { + "id": "float-cast-float32-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ff0000017f" + } + }, + { + "id": "float-cast-float32-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffff000000000001007f" + } + }, + { + "id": "float-cast-float32-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000000000000000000010000007f" + } + }, + { + "id": "float-cast-float32-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff000000000000000000000000000000000000000000000001000000000000007f" + } + }, + { + "id": "float-cast-float32-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float32-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float32-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float32-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float32-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bff3333380000000000000003ff3333342ffcccd" + } + }, + { + "id": "float-cast-float32-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 20, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bffe666660000000800000000000000000000000000000003ffe666660000000405ff999a0000000" + } + }, + { + "id": "nonfinite-cast-float32-int8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float32-int16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float32-int32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float32-int64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float32-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float32-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float32-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float32-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float64-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "0100000101" + } + }, + { + "id": "float-cast-float64-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ff0000017f" + } + }, + { + "id": "float-cast-float64-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffff000000000001007f" + } + }, + { + "id": "float-cast-float64-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000000000000000000010000007f" + } + }, + { + "id": "float-cast-float64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff000000000000000000000000000000000000000000000001000000000000007f" + } + }, + { + "id": "float-cast-float64-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float64-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float64-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float64-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "float-cast-float64-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bff3333380000000000000003ff3333342ffcccd" + } + }, + { + "id": "float-cast-float64-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 40, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bffe666666666666800000000000000000000000000000003ffe666666666666405ff9999999999a" + } + }, + { + "id": "nonfinite-cast-float64-int8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float64-int16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float64-int32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float64-int64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float64-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float64-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float64-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "nonfinite-cast-float64-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "intermediate-not-output-driven", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000002" + } + }, + { + "id": "power-wrapping-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7f0001" + } + }, + { + "id": "power-wrapping-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fff04000001" + } + }, + { + "id": "power-wrapping-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff0000040000000001" + } + }, + { + "id": "power-wrapping-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff00000000000004000000000000000001" + } + }, + { + "id": "power-wrapping-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0001" + } + }, + { + "id": "power-wrapping-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff04000001" + } + }, + { + "id": "power-wrapping-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000040000000001" + } + }, + { + "id": "power-wrapping-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000004000000000000000001" + } + }, + { + "id": "comparison-rounded-int64-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "00" + } + }, + { + "id": "comparison-rounded-uint64-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "00" + } + }, + { + "id": "capture-int8-weak-int", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010203" + } + }, + { + "id": "capture-int8-weak-float", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000" + } + }, + { + "id": "capture-int8-typed-int", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000020000000000000003" + } + }, + { + "id": "capture-int8-typed-float", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000" + } + }, + { + "id": "capture-int8-typed-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f0000003fc0000040200000" + } + }, + { + "id": "capture-float32-weak-int", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040400000" + } + }, + { + "id": "capture-float32-weak-float", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f0000003fc0000040200000" + } + }, + { + "id": "capture-float32-typed-int", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004008000000000000" + } + }, + { + "id": "capture-float32-typed-float", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000" + } + }, + { + "id": "capture-float32-typed-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f0000003fc0000040200000" + } + }, + { + "id": "capture-float64-weak-int", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004008000000000000" + } + }, + { + "id": "capture-float64-weak-float", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000" + } + }, + { + "id": "capture-float64-typed-int", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004008000000000000" + } + }, + { + "id": "capture-float64-typed-float", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000" + } + }, + { + "id": "capture-float64-typed-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000" + } + }, + { + "id": "noncontracting-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "00000000" + } + }, + { + "id": "float-divmod-float32-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 80, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "41100000c1200000426c0000c27000007fc000007fc00000800000008000000000000000bf800000" + } + }, + { + "id": "float-divmod-float32-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 80, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "3dcccccb328000003dccccc133c000007fc000007fc000008000000000000000404000007f800000" + } + }, + { + "id": "noncontracting-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "float-divmod-float64-floor", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 160, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "4022000000000000c024000000000000404d800000000000c04e0000000000007ff80000000000007ff8000000000000800000000000000080000000000000000000000000000000bff0000000000000" + } + }, + { + "id": "float-divmod-float64-mod", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 160, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "3fb99999999999963c900000000000003fb99999999999823cb80000000000007ff80000000000007ff80000000000008000000000000000000000000000000040080000000000007ff0000000000000" + } + } + ], + "python": [ + { + "id": "promotion-bool-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-subtract", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-bool-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-bool-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-bool-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int8-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int16-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int32-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-int64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-int64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-int64-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint8-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint16-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint32-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-uint64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-uint64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-uint64-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bf8000003f80000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000003f800000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007fc0000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float32-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "promotion-float64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "compare-float64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "bff00000000000003ff00000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff80000000000000000000000000000", + "classes": [ + "positive_zero", + "nan", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "mixed-float64-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-add", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-subtract", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000000000000000000007ff0000000000000", + "classes": [ + "finite", + "positive_zero", + "positive_inf" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-power", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "020001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-bool-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-bool-positive", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-bool-negative", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-bool-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-bool-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-bool-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000200000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-bool-128", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000008100000000000000800000000000000081" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-bool-negative-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff0000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-bool-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff80000000000003fe00000000000003ff8000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-bool-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-add", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "81810001fcfc" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7f7d0001f6fe" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80fe0000eb03" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c060000000000000404fc000000000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000", + "classes": [ + "finite", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "803f0000fd03" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100000200" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0002000001fd" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "817f0001fbff" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "817d0001fa02" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fc0001c800" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c01f0001ffff" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int8-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "807f0001f9fd" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int8-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "808100ff0703" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int8-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "807f00010703" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int8-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7f80fffe0602" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int8-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int8-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int8-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80fe00000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int8-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "803f0000ffff" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int8-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "81800102fafe" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int8-128", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int8-negative-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7f7eff00f8fc" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int8-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c05fe00000000000405fe000000000003fe00000000000003ff8000000000000c01a000000000000c004000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int8-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-add", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8001800100000001fffcfffc" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fff7ffd00000001fff6fffe" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000fffe00000000ffeb0003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0e000000000000040cfffc0000000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000", + "classes": [ + "finite", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80003fff00000000fffd0003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000000020000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000002000000000001fffd" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80017fff00000001fffbffff" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80017ffd00000001fffa0002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffc00000001ffc80000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0001fff00000001ffffffff" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int16-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001fff9fffd" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int16-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800080010000ffff00070003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int16-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80007fff0000000100070003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int16-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fff8000fffffffe00060002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int16-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int16-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int16-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000fffe0000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int16-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80003fff00000000ffffffff" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int16-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8001800000010002fffafffe" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int16-128", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8080807f008000810079007d" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int16-negative-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fff7ffeffff0000fff8fffc" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int16-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0dfffe00000000040dfffe0000000003fe00000000000003ff8000000000000c01a000000000000c004000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int16-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-add", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000001800000010000000000000001fffffffcfffffffc" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff7ffffffd0000000000000001fffffff6fffffffe" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000fffffffe0000000000000000ffffffeb00000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1e000000000000041cfffffffc000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000", + "classes": [ + "finite", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000003fffffff0000000000000000fffffffd00000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000000000000200000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000002000000000000000000000001fffffffd" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000017fffffff0000000000000001fffffffbffffffff" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000017ffffffd0000000000000001fffffffa00000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffc0000000000000001ffffffc800000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c00000001fffffff0000000000000001ffffffffffffffff" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int32-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001fffffff9fffffffd" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int32-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000008000000100000000ffffffff0000000700000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int32-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff00000000000000010000000700000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int32-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff80000000fffffffffffffffe0000000600000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int32-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int32-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int32-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000fffffffe00000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int32-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000003fffffff0000000000000000ffffffffffffffff" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int32-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000001800000000000000100000002fffffffafffffffe" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int32-128", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000808000007f0000008000000081000000790000007d" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int32-negative-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff7ffffffeffffffff00000000fffffff8fffffffc" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int32-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1dfffffffe0000041dfffffffe000003fe00000000000003ff8000000000000c01a000000000000c004000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int32-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-add", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000001800000000000000100000000000000000000000000000001fffffffffffffffcfffffffffffffffc" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff7ffffffffffffffd00000000000000000000000000000001fffffffffffffff6fffffffffffffffe" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000000fffffffffffffffe00000000000000000000000000000000ffffffffffffffeb0000000000000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043d00000000000007ff80000000000007ff0000000000000c002aaaaaaaaaaab4008000000000000", + "classes": [ + "finite", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000003fffffffffffffff00000000000000000000000000000000fffffffffffffffd0000000000000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000000000000000000000000000000000020000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-power", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000002000000000000000000000000000000000000000000000001fffffffffffffffd" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000017fffffffffffffff00000000000000000000000000000001fffffffffffffffbffffffffffffffff" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000017ffffffffffffffd00000000000000000000000000000001fffffffffffffffa0000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffc00000000000000000000000000000001ffffffffffffffc80000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0000000000000001fffffffffffffff00000000000000000000000000000001ffffffffffffffffffffffffffffffff" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-int64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int64-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001fffffffffffffff9fffffffffffffffd" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int64-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "800000000000000080000000000000010000000000000000ffffffffffffffff00000000000000070000000000000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int64-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff0000000000000000000000000000000100000000000000070000000000000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-int64-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff8000000000000000fffffffffffffffffffffffffffffffe00000000000000060000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int64-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "800000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-int64-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int64-left", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000000fffffffffffffffe0000000000000000000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-int64-right", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000003fffffffffffffff00000000000000000000000000000000ffffffffffffffffffffffffffffffff" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int64-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000001800000000000000000000000000000010000000000000002fffffffffffffffafffffffffffffffe" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int64-128", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "8000000000000080800000000000007f000000000000008000000000000000810000000000000079000000000000007d" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int64-negative-1", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff7ffffffffffffffeffffffffffffffff0000000000000000fffffffffffffff8fffffffffffffffc" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-int64-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043e00000000000003fe00000000000003ff8000000000000c01a000000000000c004000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-int64-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-add", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010406" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffd00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fe00000409" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000405fe000000000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "007f00000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00010101041b" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000200000203" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "01ff00010203" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "01fd00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fc00010818" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "003f00010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint8-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint8-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00ff00010203" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint8-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100fffefd" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint8-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00ff00010203" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint8-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ff00fffefdfc" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint8-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint8-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint8-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00fe00000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint8-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "007f00000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint8-1", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001020304" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint8-128", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "807f80818283" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint8-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint8-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe0000000000000406ff000000000003fe00000000000003ff80000000000004004000000000000400c000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint8-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-add", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000000100040006" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffffffd0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffe0000000000040009" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040dfffe0000000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00007fff0000000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000001000100010004001b" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000020000000000020003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0001ffff0000000100020003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0001fffd0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffc0000000100080018" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00003fff0000000100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint16-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint16-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff0000000100020003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint16-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000fffffffefffd" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint16-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff0000000100020003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint16-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ffff0000fffffffefffdfffc" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint16-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint16-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint16-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000fffe0000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint16-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00007fff0000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint16-1", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100000001000200030004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint16-128", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0080007f0080008100820083" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint16-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint16-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe000000000000040effff0000000003fe00000000000003ff80000000000004004000000000000400c000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint16-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-add", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000000000000010000000400000006" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffffffffffffffd00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffe00000000000000000000000400000009" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000041dfffffffe000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000007fffffff00000000000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000100000001000000040000001b" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000200000000000000000000000200000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000001ffffffff00000000000000010000000200000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000001fffffffd00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffc00000000000000010000000800000018" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000003fffffff00000000000000010000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint32-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff00000000000000010000000200000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint32-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000fffffffffffffffefffffffd" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint32-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff00000000000000010000000200000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint32-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff00000000fffffffffffffffefffffffdfffffffc" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint32-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint32-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint32-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000fffffffe00000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint32-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000007fffffff00000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint32-1", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000000000001000000020000000300000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint32-128", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000800000007f00000080000000810000008200000083" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint32-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint32-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe000000000000041effffffff000003fe00000000000003ff80000000000004004000000000000400c000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint32-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-add", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000000000000000000000100000000000000040000000000000006" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "fffffffffffffffffffffffffffffffd0000000000000000000000000000000100000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffe0000000000000000000000000000000000000000000000040000000000000009" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000043e00000000000007ff80000000000007ff00000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "nan", + "positive_inf", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007fffffffffffffff0000000000000000000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001000000000000000100000000000000010000000000000004000000000000001b" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-bit-and", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000020000000000000000000000000000000000000000000000020000000000000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-bit-or", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001ffffffffffffffff0000000000000000000000000000000100000000000000020000000000000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-bit-xor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001fffffffffffffffd0000000000000000000000000000000100000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-shift-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffc0000000000000000000000000000000100000000000000080000000000000018" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-shift-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fffffffffffffff0000000000000000000000000000000100000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-uint64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000101010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint64-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff0000000000000000000000000000000100000000000000020000000000000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint64-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000000fffffffffffffffffffffffffffffffefffffffffffffffd" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint64-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff0000000000000000000000000000000100000000000000020000000000000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-uint64-invert", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff0000000000000000fffffffffffffffffffffffffffffffefffffffffffffffdfffffffffffffffc" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint64-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "integer-divisor-boundary-uint64-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint64-left", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000fffffffffffffffe0000000000000000000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "shift-boundary-uint64-right", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007fffffffffffffff0000000000000000000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint64-1", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000000000000000000001000000000000000200000000000000030000000000000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint64-128", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000080000000000000007f0000000000000080000000000000008100000000000000820000000000000083" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint64-negative-1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-uint64-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "3fe000000000000043f00000000000003fe00000000000003ff80000000000004004000000000000400c000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-uint64-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010001000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-add", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0800000c080000000000000400000003e4ccccd3f8ccccd", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1200000c000000000000000c0000000000000003f666666", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1a800004040000000000000800000003c23d70b3dcccccd", + "classes": [ + "finite", + "finite", + "positive_zero", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0155555404000007fc00000800000003f80000041200000", + "classes": [ + "finite", + "finite", + "nan", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0400000404000007fc00000800000003f80000041100000", + "classes": [ + "finite", + "finite", + "nan", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "40000000800000007fc0000000000000000000003dcccccb", + "classes": [ + "finite", + "negative_zero", + "nan", + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c3ab8000beaaaaab3f800000000000003f4b59183f800000", + "classes": [ + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float32-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float32-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0e00000c040000000000000800000003dcccccd3f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float32-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "40e00000404000008000000000000000bdcccccdbf800000", + "classes": [ + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float32-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "40e000004040000000000000000000003dcccccd3f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float32-invert", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float32-1", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0c00000c00000003f8000003f8000003f8ccccd40000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float32-128", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "42f2000042fa000043000000430000004300199a43010000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float32-negative-1", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c1000000c0800000bf800000bf800000bf66666600000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float32-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0d00000c02000003f0000003f0000003f19999a3fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float32-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-add", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c010000000000000c010000000000000000000000000000040000000000000003fc999999999999a3ff199999999999a", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-subtract", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c024000000000000c0000000000000000000000000000000c00000000000000000000000000000003feccccccccccccd", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-multiply", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c0350000000000004008000000000000000000000000000080000000000000003f847ae147ae147c3fb999999999999a", + "classes": [ + "finite", + "finite", + "positive_zero", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c002aaaaaaaaaaab40080000000000007ff800000000000080000000000000003ff00000000000004024000000000000", + "classes": [ + "finite", + "finite", + "nan", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-floor-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c00800000000000040080000000000007ff800000000000080000000000000003ff00000000000004022000000000000", + "classes": [ + "finite", + "finite", + "nan", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-remainder", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "400000000000000080000000000000007ff8000000000000000000000000000000000000000000003fb9999999999996", + "classes": [ + "finite", + "negative_zero", + "nan", + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-power", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c075700000000000bfd55555555555553ff000000000000000000000000000003fe96b230bcdc4343ff0000000000000", + "classes": [ + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-bit-and", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-bit-or", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-bit-xor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-shift-left", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-shift-right", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-not-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-less-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-greater", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "operator-float64-greater-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000001000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float64-positive", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c01c000000000000c008000000000000000000000000000080000000000000003fb999999999999a3ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "negative_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float64-negative", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "401c000000000000400800000000000080000000000000000000000000000000bfb999999999999abff0000000000000", + "classes": [ + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float64-absolute", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "401c0000000000004008000000000000000000000000000000000000000000003fb999999999999a3ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "unary-float64-invert", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float64-1", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c018000000000000c0000000000000003ff00000000000003ff00000000000003ff199999999999a4000000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float64-128", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "405e400000000000405f4000000000004060000000000000406000000000000040600333333333334060200000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-128-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-128-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float64-negative-1", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c020000000000000c010000000000000bff0000000000000bff0000000000000bfeccccccccccccd0000000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-negative-1-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-negative-1-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010100000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-float64-0point-5", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "c01a000000000000c0040000000000003fe00000000000003fe00000000000003fe33333333333333ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-0point-5-equal", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "weak-compare-float64-0point-5-less", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 6 + ], + "encoding": "raw-be-hex", + "hex": "010101010100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-bool-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-bool-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int8-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int16-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint8-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint16-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-float32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-bool-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int8-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int16-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-float32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int8-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int16-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-float32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int16-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int32-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-int64-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int16-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint8-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint16-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-float32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint8-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint16-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-float32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint16-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint32-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint8-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint16-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-uint64-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-float32-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float32-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-bool-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-bool-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-bool-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-int64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint8-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint8-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint8-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint16-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint16-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint16-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint32-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint64-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint64-same-kind", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-uint64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-float32-safe", + "status": -4, + "category": "binding_error", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-float32-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-float32-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-float64-safe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-float64-same-kind", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-float64-float64-unsafe", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "807f0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ff80007f00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffff800000007f0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffff80000000000000007f00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c300000042fe0000000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c300000042fe0000000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c060000000000000405fc0000000000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c060000000000000405fc0000000000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80007fff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffff800000007fff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffff80000000000000007fff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c700000046fffe00000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c700000046fffe00000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c0e000000000000040dfffc00000000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c0e000000000000040dfffc00000000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "800000007fffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff80000000000000007fffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "cf0000004f000000000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "cf0000004f000000000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c1e000000000000041dfffffffc0000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c1e000000000000041dfffffffc0000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "01010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "80000000000000007fffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "df0000005f000000000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "df0000005f000000000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-int64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043e000000000000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-int64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "c3e000000000000043e000000000000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000ff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000ff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000ff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000437f0000000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000437f0000000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000406fe0000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint8-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000406fe0000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000ffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000ffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000477fff00000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000477fff00000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040efffe00000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint16-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040efffe00000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000ffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000004f800000000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000004f800000000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000041efffffffe0000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000041efffffffe0000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000ffff00000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "00000000ffffffff0000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000ffffffffffffffff00000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000005f800000000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000005f800000000000003f800000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "cast-boundary-uint64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000043f000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "explicit-uint64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000043f000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "0100000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ff0000017f" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffff000000000001007f" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000000000000000000010000007f" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff000000000000000000000000000000000000000000000001000000000000007f" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bff3333380000000000000003ff3333342ffcccd", + "classes": [ + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float32-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bffe666660000000800000000000000000000000000000003ffe666660000000405ff999a0000000", + "classes": [ + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-int8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-int16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-int32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-int64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float32-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "0100000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ff0000017f" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffff000000000001007f" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000000000000000000000010000007f" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff000000000000000000000000000000000000000000000001000000000000007f" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bff3333380000000000000003ff3333342ffcccd", + "classes": [ + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-cast-float64-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 5 + ], + "encoding": "raw-be-hex", + "hex": "bffe666666666666800000000000000000000000000000003ffe666666666666405ff9999999999a", + "classes": [ + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-int8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-int16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-int32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-int64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-uint8", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-uint16", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-uint32", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "nonfinite-cast-float64-uint64", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "intermediate-not-output-driven", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7f0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fff04000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fffffff0000040000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fffffffffffffff00000000000004000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff0001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffff04000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffff0000040000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "power-wrapping-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ffffffffffffffff00000000000004000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "comparison-rounded-int64-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "00" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "comparison-rounded-uint64-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "00" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-int8-weak-int", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010203" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-int8-weak-float", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-int8-typed-int", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000020000000000000003" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-int8-typed-float", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-int8-typed-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f0000003fc0000040200000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float32-weak-int", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040400000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float32-weak-float", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f0000003fc0000040200000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float32-typed-int", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004008000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float32-typed-float", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float32-typed-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f0000003fc0000040200000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float64-weak-int", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004008000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float64-weak-float", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float64-typed-int", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004008000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float64-typed-float", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "capture-float64-typed-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fe00000000000003ff80000000000004004000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "noncontracting-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "00000000", + "classes": [ + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-divmod-float32-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "41100000c1200000426c0000c27000007fc000007fc00000800000008000000000000000bf800000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "nan", + "nan", + "negative_zero", + "negative_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-divmod-float32-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "3dcccccb328000003dccccc133c000007fc000007fc000008000000000000000404000007f800000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "nan", + "nan", + "negative_zero", + "positive_zero", + "finite", + "positive_inf" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "noncontracting-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-divmod-float64-floor", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "4022000000000000c024000000000000404d800000000000c04e0000000000007ff80000000000007ff8000000000000800000000000000080000000000000000000000000000000bff0000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "nan", + "nan", + "negative_zero", + "negative_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "float-divmod-float64-mod", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 10 + ], + "encoding": "raw-be-hex", + "hex": "3fb99999999999963c900000000000003fb99999999999823cb80000000000007ff80000000000007ff80000000000008000000000000000000000000000000040080000000000007ff0000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "nan", + "nan", + "negative_zero", + "positive_zero", + "finite", + "positive_inf" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + } + ] + } + } +} diff --git a/plans/menudet-m3-signoff.md b/plans/menudet-m3-signoff.md new file mode 100644 index 000000000..0d3a3a9da --- /dev/null +++ b/plans/menudet-m3-signoff.md @@ -0,0 +1,132 @@ +# M3 — arithmetic, promotion and conversion + +Date: 2026-10-09. Reference: NumPy 2.5.3, macOS arm64. + +## Outcome and acceptance qualification + +M3 implementation is complete for the **declared** bool, signed/unsigned +8/16/32/64-bit and float32/64 dtype/operator/cast matrix. The opt-in schema and +language **1.1 / 1.1** profile is independent of checked 1.0; no saved artifacts +are upgraded or silently reinterpreted. Source validation, native execution, +metadata-only inference, Python lowering, captures and persistence are covered. + +The plan's broader **cross-native-platform acceptance is not yet signed off**: +Linux and Windows jobs register the corpus, but have not been executed here. +Verified execution is macOS arm64 and standalone Node/WASM. No eligible portable +JIT/SIMD implementation exists; explicit on requests execute the interpreter, +and required acceleration rejects. Full-DSL compiler controls are not evidence +of portable arithmetic conformance. There is no new accelerated path to qualify. +NumPy 1.26 integration and release wheels also remain unqualified. + +## Implemented slices + +- Fixed-width modular add/subtract/multiply/power, unary negation/absolute value, + signed minima, integral true/floor division and remainder, bitwise operations, + all comparisons and defined negative/oversized shifts. Signed arithmetic uses + unsigned bits and explicit reconstruction instead of undefined C overflow. +- Boolean restrictions/result types, strong signed/unsigned/float promotion, + weak literals, weak plain numeric captures, strong NumPy scalar captures and + typed zero-dimensional inputs. Exact mixed-integer comparisons intentionally + differ from the float64 arithmetic promotion of int64/uint64 pairs. +- Metadata-only inference before output conversion; public native + `me_artifact_inferred_dtype()` and Python `PortableKernel.inferred_dtype`. + Changing output width does not change intermediate arithmetic width. +- Native fixed-width cast syntax, modular array integer narrowing, checked weak + scalar construction, direct float-width conversion and Boolean truth casts. + `safe` / `same_kind` / `unsafe` output policies validate before reading data. +- NumPy's corrected floating floor division; float32 intermediates stay float32, + multiply/add do not contract, and native evaluation restores the caller's FP + environment. WASM tests numerical values under its fixed-nearest environment; + alternate rounding and IEEE exception-flag probes are host-only. +- Artifact scalar categories, authoring captures and persisted lazy recipes + preserve version/profile/type intent without reconstructing Python functions. + +Defined divergence: floating-to-integer conversion truncates but rejects +nonfinite or truncated out-of-range values, including negative unsigned results, +rather than preserving platform/compiler-dependent NumPy sentinel integers. +Weak-only integers are bounded by int64 transport; arbitrary-precision Python +arithmetic is not implemented. Aggregated NumPy-like floating warnings/status +remain M4 work. Array broadcasting is outside this matrix. + +## Corpus and evidence + +Native-owned `../miniexpr/tests/numpy-compat/arithmetic-v1.1.json` contains +**3,193 cases**: **2,793 independently regenerable NumPy value references** and +**400 native-contract diagnostic cases**. Contract diagnostic successes must not +be described as 400 extra NumPy numerical parity passes. The corpus includes all +121 strong dtype pairs, the operator/type matrix, 363 policy/type combinations, +boundary casts, weak scalar comparisons/construction, signed-minimum/-1, +zero divisors, extreme shifts, captures and noncontraction controls. + +`tools/menudet_arithmetic.py` generates the corpus from pinned NumPy, with an +independent declarative ufunc recipe for drift checking (no source eval). +`plans/menudet-m3-conformance.json` records paired standalone/native and integrated +Python off/on results, hashes and provenance: every case matches its declared +contract, reference drift is empty and eligible JIT cases are zero. Inferred +dtype checks are independent of requested output dtype in both readers. + +Seeded PCG64 property tests use seeds 1729 and 20261009, each with 128 cases of +16 full-width random lanes across all eight integer widths. They cover wrapping, +floor division, remainder, extreme shifts and comparisons rather than only safe +small-value addition. Historical M1/M2 checked-profile vectors remain unchanged. + +## Reproduction + +Validation results: + +- Full Python suite: **12,265 passed, 55 skipped**. +- Full native CTest suite: **423 passed**. +- ASan/UBSan checkpoint/conformance/arithmetic/example checks: **7 passed**. +- Focused Python integration tests against the sanitized C runner: **17 passed**. +- Node/WASM checkpoint/conformance/arithmetic/example checks: **7 passed**. +- JSON Schema validation, Ruff lint/format and both repositories' whitespace + checks pass. Native/extension builds introduce no compiler warnings. + +One initial full-suite invocation used a nonexistent v2 corpus filename; those +setup errors disappeared after correcting the selector to `vectors-v2.json`. +An initial sanitizer invocation had not built the standalone example target; +building it and rerunning all seven checks passed. Neither was a code regression. +The first WASM configuration emitted CMake's shared-library fallback warning; +explicitly selecting `MINIEXPR_BUILD_SHARED=OFF` removed it before validation. + +All Python, build and test commands use the `blosc2` conda environment. The editable +development extension was built with the **explicit** modified native checkout; +the repository dependency pin and default backends were not changed: + +```sh +conda run -n blosc2 python -m pip install -e . --no-build-isolation --no-deps \ + --config-settings=cmake.define.FETCHCONTENT_SOURCE_DIR_MINIEXPR=/Users/faltet/blosc/miniexpr + +conda run -n blosc2 python -m tools.menudet_arithmetic \ + /Users/faltet/blosc/miniexpr/tests/numpy-compat/arithmetic-v1.1.json + +conda run -n blosc2 python -m tools.menudet_conformance run \ + /Users/faltet/blosc/miniexpr/tests/numpy-compat/arithmetic-v1.1.json \ + --native-runner "$NATIVE_BUILD/tests/numpy_compat_runner" \ + --work-dir "$WORK_DIR" --report plans/menudet-m3-conformance.json + +MENUDET_NUMPY_ARITHMETIC_CORPUS=/Users/faltet/blosc/miniexpr/tests/numpy-compat/arithmetic-v1.1.json \ +MENUDET_NUMPY_CORPUS=/Users/faltet/blosc/miniexpr/tests/numpy-compat/vectors.json \ +MENUDET_NUMPY_CORPUS_V2=/Users/faltet/blosc/miniexpr/tests/numpy-compat/vectors-v2.json \ +MENUDET_NUMPY_RUNNER="$NATIVE_BUILD/tests/numpy_compat_runner" \ +MINIEXPR_ARTIFACT_RUNNER="$NATIVE_BUILD/tests/portable_artifact_runner" \ +conda run -n blosc2 pytest -q + +conda run -n blosc2 ctest --test-dir "$NATIVE_BUILD" --output-on-failure -j 8 +conda run -n blosc2 ctest --test-dir "$SANITIZED_BUILD" -R numpy_compat --output-on-failure +conda run -n blosc2 ctest --test-dir "$WASM_BUILD" -R numpy_compat --output-on-failure +``` + +Build roots under the approved OpenCode temporary directory: + +- Native: `menudet-m1-jit-build` (existing TCC/GCC-capable controls). +- Sanitized: `menudet-checkpoint-sanitize` (ASan/UBSan). +- Python extension: `menudet-m3-python-build`. +- WASM: `menudet-m3-wasm-build`, Emscripten toolchain, Node emulator, artifact + support on, shared library/TCC/WASM JIT/Accelerate/SLEEF off. Runner uses + NODERAWFS, a 1 MiB stack and explicit exit-runtime handling. The original small + WASM stack exhausted on the larger corpus; this is a runner resource setting, + not an arithmetic exception bypass. + +The native contract is documented in `../miniexpr/doc/numpy-arithmetic-1.1.md`; +Python usage is in `doc/reference/portable_dsl.rst`. diff --git a/plans/menudet-m4-conformance.json b/plans/menudet-m4-conformance.json new file mode 100644 index 000000000..42e11fcc6 --- /dev/null +++ b/plans/menudet-m4-conformance.json @@ -0,0 +1,114919 @@ +{ + "schema_version": "menudet-conformance-report-2", + "provenance": { + "python_revision": "cf6f25c1020c13864413e97b39e466c893b77a7b", + "runner_sha256": "a61e49a5428dde9d613747897413db94b2acb578533bd116098dad82cc13030a", + "extension_sha256": "3b133ae2ac8ee1a295e6baabdded2939998833eea81c6ebc52794917d0bdf712", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py", + "generator_revision": "m4-1", + "corpus_sha256": "359d341d79a62cdf28546ccaf3888fca51383201b149f403f90272f395536192", + "semantic_revisions": [ + "menudet-numpy-1.1" + ], + "local_changes": "M4 native 1.1 function signatures, accuracy and scoped floating status; checked 1.0 retained" + }, + "reference_numpy": "2.5.3", + "installed_numpy": "2.5.3", + "reference_drift": [], + "eligible_jit_cases": 0, + "requests": { + "off": { + "native": [ + { + "id": "signature-sin-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sin-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sin-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f576aa43f68c7b7" + } + }, + { + "id": "signature-sin-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446" + } + }, + { + "id": "signature-sin-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446" + } + }, + { + "id": "signature-sin-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sin-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f576aa43f68c7b7" + } + }, + { + "id": "signature-sin-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446" + } + }, + { + "id": "signature-sin-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446" + } + }, + { + "id": "signature-sin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f576aa43f68c7b7" + } + }, + { + "id": "signature-sin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446" + } + }, + { + "id": "signature-cos-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cos-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cos-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f0a5140bed51133" + } + }, + { + "id": "signature-cos-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205" + } + }, + { + "id": "signature-cos-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205" + } + }, + { + "id": "signature-cos-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cos-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f0a5140bed51133" + } + }, + { + "id": "signature-cos-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205" + } + }, + { + "id": "signature-cos-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205" + } + }, + { + "id": "signature-cos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f0a5140bed51133" + } + }, + { + "id": "signature-cos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205" + } + }, + { + "id": "signature-tan-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-tan-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-tan-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc75923c00bd7b1" + } + }, + { + "id": "signature-tan-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8" + } + }, + { + "id": "signature-tan-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8" + } + }, + { + "id": "signature-tan-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-tan-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc75923c00bd7b1" + } + }, + { + "id": "signature-tan-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8" + } + }, + { + "id": "signature-tan-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8" + } + }, + { + "id": "signature-tan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc75923c00bd7b1" + } + }, + { + "id": "signature-tan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8" + } + }, + { + "id": "signature-sinh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sinh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sinh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f966cfe40681e7b" + } + }, + { + "id": "signature-sinh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f" + } + }, + { + "id": "signature-sinh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f" + } + }, + { + "id": "signature-sinh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sinh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f966cfe40681e7b" + } + }, + { + "id": "signature-sinh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f" + } + }, + { + "id": "signature-sinh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f" + } + }, + { + "id": "signature-sinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f966cfe40681e7b" + } + }, + { + "id": "signature-sinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f" + } + }, + { + "id": "signature-cosh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cosh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cosh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fc583ab4070c7d0" + } + }, + { + "id": "signature-cosh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc" + } + }, + { + "id": "signature-cosh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc" + } + }, + { + "id": "signature-cosh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cosh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fc583ab4070c7d0" + } + }, + { + "id": "signature-cosh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc" + } + }, + { + "id": "signature-cosh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc" + } + }, + { + "id": "signature-cosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fc583ab4070c7d0" + } + }, + { + "id": "signature-cosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc" + } + }, + { + "id": "signature-tanh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-tanh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-tanh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f42f7d63f76ca83" + } + }, + { + "id": "signature-tanh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4" + } + }, + { + "id": "signature-tanh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4" + } + }, + { + "id": "signature-tanh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-tanh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f42f7d63f76ca83" + } + }, + { + "id": "signature-tanh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4" + } + }, + { + "id": "signature-tanh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4" + } + }, + { + "id": "signature-tanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f42f7d63f76ca83" + } + }, + { + "id": "signature-tanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4" + } + }, + { + "id": "signature-sqrt-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sqrt-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sqrt-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fb504f3" + } + }, + { + "id": "signature-sqrt-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd" + } + }, + { + "id": "signature-sqrt-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd" + } + }, + { + "id": "signature-sqrt-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sqrt-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fb504f3" + } + }, + { + "id": "signature-sqrt-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd" + } + }, + { + "id": "signature-sqrt-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd" + } + }, + { + "id": "signature-sqrt-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fb504f3" + } + }, + { + "id": "signature-sqrt-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd" + } + }, + { + "id": "signature-cbrt-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cbrt-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cbrt-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fa14518" + } + }, + { + "id": "signature-cbrt-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b" + } + }, + { + "id": "signature-cbrt-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b" + } + }, + { + "id": "signature-cbrt-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cbrt-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fa14518" + } + }, + { + "id": "signature-cbrt-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b" + } + }, + { + "id": "signature-cbrt-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b" + } + }, + { + "id": "signature-cbrt-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fa14518" + } + }, + { + "id": "signature-cbrt-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b" + } + }, + { + "id": "signature-exp-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-exp-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-exp-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f800000402df85440ec7326" + } + }, + { + "id": "signature-exp-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae" + } + }, + { + "id": "signature-exp-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae" + } + }, + { + "id": "signature-exp-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-exp-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f800000402df85440ec7326" + } + }, + { + "id": "signature-exp-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae" + } + }, + { + "id": "signature-exp-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae" + } + }, + { + "id": "signature-exp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f800000402df85440ec7326" + } + }, + { + "id": "signature-exp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae" + } + }, + { + "id": "signature-exp2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-exp2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-exp2-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040800000" + } + }, + { + "id": "signature-exp2-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000" + } + }, + { + "id": "signature-exp2-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000" + } + }, + { + "id": "signature-exp2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-exp2-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040800000" + } + }, + { + "id": "signature-exp2-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000" + } + }, + { + "id": "signature-exp2-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000" + } + }, + { + "id": "signature-exp2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040800000" + } + }, + { + "id": "signature-exp2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000" + } + }, + { + "id": "signature-expm1-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-expm1-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-expm1-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fdbf0a940cc7326" + } + }, + { + "id": "signature-expm1-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae" + } + }, + { + "id": "signature-expm1-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae" + } + }, + { + "id": "signature-expm1-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-expm1-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fdbf0a940cc7326" + } + }, + { + "id": "signature-expm1-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae" + } + }, + { + "id": "signature-expm1-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae" + } + }, + { + "id": "signature-expm1-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fdbf0a940cc7326" + } + }, + { + "id": "signature-expm1-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae" + } + }, + { + "id": "signature-log-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218" + } + }, + { + "id": "signature-log-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-log-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-log-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218" + } + }, + { + "id": "signature-log-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-log-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-log-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218" + } + }, + { + "id": "signature-log-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-log2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log2-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f800000" + } + }, + { + "id": "signature-log2-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "signature-log2-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "signature-log2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log2-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f800000" + } + }, + { + "id": "signature-log2-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "signature-log2-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "signature-log2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f800000" + } + }, + { + "id": "signature-log2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "signature-log10-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log10-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log10-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003e9a209b" + } + }, + { + "id": "signature-log10-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff" + } + }, + { + "id": "signature-log10-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff" + } + }, + { + "id": "signature-log10-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log10-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003e9a209b" + } + }, + { + "id": "signature-log10-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff" + } + }, + { + "id": "signature-log10-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff" + } + }, + { + "id": "signature-log10-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003e9a209b" + } + }, + { + "id": "signature-log10-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff" + } + }, + { + "id": "signature-log1p-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log1p-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log1p-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f3172183f8c9f54" + } + }, + { + "id": "signature-log1p-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b" + } + }, + { + "id": "signature-log1p-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b" + } + }, + { + "id": "signature-log1p-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log1p-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f3172183f8c9f54" + } + }, + { + "id": "signature-log1p-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b" + } + }, + { + "id": "signature-log1p-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b" + } + }, + { + "id": "signature-log1p-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f3172183f8c9f54" + } + }, + { + "id": "signature-log1p-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b" + } + }, + { + "id": "signature-ceil-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-ceil-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-ceil-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-ceil-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-ceil-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-ceil-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-ceil-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-ceil-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-ceil-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-ceil-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-ceil-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-floor-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-floor-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-floor-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-floor-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-floor-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-floor-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-floor-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-floor-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-floor-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-floor-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-floor-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-trunc-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-trunc-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-trunc-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-trunc-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-trunc-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-trunc-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-trunc-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-trunc-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-trunc-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-trunc-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-trunc-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-rint-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-rint-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-rint-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-rint-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-rint-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-rint-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-rint-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-rint-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-rint-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-rint-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-rint-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-round-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-round-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-round-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-round-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-round-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-round-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-round-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-round-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-round-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-round-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-round-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-sign-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sign-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-sign-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "signature-sign-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "signature-sign-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "signature-sign-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-sign-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "signature-sign-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "signature-sign-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "signature-sign-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "signature-sign-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "signature-square-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-square-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + } + }, + { + "id": "signature-square-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + } + }, + { + "id": "signature-square-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + } + }, + { + "id": "signature-square-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + } + }, + { + "id": "signature-square-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + } + }, + { + "id": "signature-square-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + } + }, + { + "id": "signature-square-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + } + }, + { + "id": "signature-square-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + } + }, + { + "id": "signature-square-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040800000" + } + }, + { + "id": "signature-square-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004010000000000000" + } + }, + { + "id": "signature-conj-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-conj-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-conj-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-conj-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-conj-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-conj-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-conj-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-conj-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-conj-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-conj-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-conj-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-real-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-real-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-real-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-real-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-real-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-real-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-real-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-real-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-real-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-real-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-real-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-imag-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-imag-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-imag-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "signature-imag-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-imag-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-imag-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-imag-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "signature-imag-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-imag-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-imag-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-imag-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-isfinite-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isinf-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-fabs-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-fabs-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-fabs-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-fabs-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-fabs-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-fabs-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-fabs-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-fabs-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-fabs-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-fabs-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-fabs-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-absolute-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-absolute-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-absolute-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-absolute-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-absolute-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-absolute-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-absolute-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-absolute-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-absolute-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-absolute-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-absolute-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-abs-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-abs-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-abs-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-abs-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-abs-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-abs-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-abs-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-abs-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-abs-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-abs-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-abs-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-ln-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-ln-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-ln-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218" + } + }, + { + "id": "signature-ln-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-ln-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-ln-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-ln-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218" + } + }, + { + "id": "signature-ln-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-ln-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-ln-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218" + } + }, + { + "id": "signature-ln-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-acos-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-acos-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-acos-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000" + } + }, + { + "id": "signature-acos-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-acos-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-acos-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-acos-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000" + } + }, + { + "id": "signature-acos-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-acos-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-acos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000" + } + }, + { + "id": "signature-acos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-asin-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-asin-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-asin-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000" + } + }, + { + "id": "signature-asin-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-asin-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-asin-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-asin-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000" + } + }, + { + "id": "signature-asin-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-asin-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-asin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000" + } + }, + { + "id": "signature-asin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-atan-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atan-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atan-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d" + } + }, + { + "id": "signature-atan-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-atan-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-atan-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atan-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d" + } + }, + { + "id": "signature-atan-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-atan-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-atan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d" + } + }, + { + "id": "signature-atan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-acosh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-acosh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-acosh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214" + } + }, + { + "id": "signature-acosh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-acosh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-acosh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-acosh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214" + } + }, + { + "id": "signature-acosh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-acosh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-acosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214" + } + }, + { + "id": "signature-acosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-asinh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-asinh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-asinh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c" + } + }, + { + "id": "signature-asinh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-asinh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-asinh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-asinh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c" + } + }, + { + "id": "signature-asinh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-asinh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-asinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c" + } + }, + { + "id": "signature-asinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-atanh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atanh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atanh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000" + } + }, + { + "id": "signature-atanh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-atanh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-atanh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atanh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000" + } + }, + { + "id": "signature-atanh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-atanh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-atanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000" + } + }, + { + "id": "signature-atanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-arccos-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arccos-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arccos-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000" + } + }, + { + "id": "signature-arccos-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-arccos-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-arccos-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arccos-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000" + } + }, + { + "id": "signature-arccos-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-arccos-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-arccos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000" + } + }, + { + "id": "signature-arccos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-arcsin-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arcsin-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arcsin-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000" + } + }, + { + "id": "signature-arcsin-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-arcsin-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-arcsin-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arcsin-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000" + } + }, + { + "id": "signature-arcsin-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-arcsin-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-arcsin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000" + } + }, + { + "id": "signature-arcsin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-arctan-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctan-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctan-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d" + } + }, + { + "id": "signature-arctan-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-arctan-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-arctan-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctan-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d" + } + }, + { + "id": "signature-arctan-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-arctan-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-arctan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d" + } + }, + { + "id": "signature-arctan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-arccosh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arccosh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arccosh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214" + } + }, + { + "id": "signature-arccosh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-arccosh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-arccosh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arccosh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214" + } + }, + { + "id": "signature-arccosh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-arccosh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-arccosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214" + } + }, + { + "id": "signature-arccosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-arcsinh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arcsinh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arcsinh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c" + } + }, + { + "id": "signature-arcsinh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-arcsinh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-arcsinh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arcsinh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c" + } + }, + { + "id": "signature-arcsinh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-arcsinh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-arcsinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c" + } + }, + { + "id": "signature-arcsinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-arctanh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctanh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctanh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000" + } + }, + { + "id": "signature-arctanh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-arctanh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-arctanh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctanh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000" + } + }, + { + "id": "signature-arctanh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-arctanh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-arctanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000" + } + }, + { + "id": "signature-arctanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-minimum-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-minimum-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-minimum-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-minimum-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-minimum-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-minimum-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-minimum-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-minimum-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-minimum-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-minimum-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-minimum-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-maximum-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-maximum-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "signature-maximum-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "signature-maximum-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "signature-maximum-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "signature-maximum-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "signature-maximum-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "signature-maximum-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "signature-maximum-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "signature-maximum-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "signature-maximum-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-fmin-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-fmin-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-fmin-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-fmin-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-fmin-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-fmin-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-fmin-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-fmin-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-fmin-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-fmin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-fmin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-fmax-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-fmax-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "signature-fmax-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "signature-fmax-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "signature-fmax-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "signature-fmax-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "signature-fmax-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "signature-fmax-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "signature-fmax-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "signature-fmax-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "signature-fmax-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-hypot-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-hypot-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-hypot-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fb504f3403504f3" + } + }, + { + "id": "signature-hypot-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd" + } + }, + { + "id": "signature-hypot-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd" + } + }, + { + "id": "signature-hypot-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-hypot-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fb504f3403504f3" + } + }, + { + "id": "signature-hypot-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd" + } + }, + { + "id": "signature-hypot-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd" + } + }, + { + "id": "signature-hypot-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fb504f3403504f3" + } + }, + { + "id": "signature-hypot-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd" + } + }, + { + "id": "signature-copysign-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-copysign-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-copysign-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-copysign-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-copysign-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-copysign-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-copysign-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-copysign-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-copysign-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-copysign-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-copysign-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-nextafter-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-nextafter-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-nextafter-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000013f80000040000000" + } + }, + { + "id": "signature-nextafter-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000" + } + }, + { + "id": "signature-nextafter-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000" + } + }, + { + "id": "signature-nextafter-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-nextafter-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000013f80000040000000" + } + }, + { + "id": "signature-nextafter-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000" + } + }, + { + "id": "signature-nextafter-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000" + } + }, + { + "id": "signature-nextafter-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000013f80000040000000" + } + }, + { + "id": "signature-nextafter-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000" + } + }, + { + "id": "signature-logaddexp-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-logaddexp-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-logaddexp-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fa818f63fd8b90c402c5c86" + } + }, + { + "id": "signature-logaddexp-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c" + } + }, + { + "id": "signature-logaddexp-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c" + } + }, + { + "id": "signature-logaddexp-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-logaddexp-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fa818f63fd8b90c402c5c86" + } + }, + { + "id": "signature-logaddexp-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c" + } + }, + { + "id": "signature-logaddexp-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c" + } + }, + { + "id": "signature-logaddexp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fa818f63fd8b90c402c5c86" + } + }, + { + "id": "signature-logaddexp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c" + } + }, + { + "id": "signature-fmod-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-fmod-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-fmod-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "signature-fmod-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-fmod-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-fmod-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-fmod-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "signature-fmod-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-fmod-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-fmod-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-fmod-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-remainder-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-remainder-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-remainder-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "signature-remainder-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-remainder-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-remainder-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-remainder-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "signature-remainder-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-remainder-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-remainder-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-remainder-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-power-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-power-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + } + }, + { + "id": "signature-power-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + } + }, + { + "id": "signature-power-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + } + }, + { + "id": "signature-power-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + } + }, + { + "id": "signature-power-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + } + }, + { + "id": "signature-power-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + } + }, + { + "id": "signature-power-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + } + }, + { + "id": "signature-power-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + } + }, + { + "id": "signature-power-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040800000" + } + }, + { + "id": "signature-power-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004010000000000000" + } + }, + { + "id": "signature-ldexp-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-ldexp-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-ldexp-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000004000000041000000" + } + }, + { + "id": "signature-ldexp-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000" + } + }, + { + "id": "signature-ldexp-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000" + } + }, + { + "id": "signature-ldexp-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-ldexp-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000004000000041000000" + } + }, + { + "id": "signature-ldexp-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000" + } + }, + { + "id": "signature-ldexp-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000" + } + }, + { + "id": "signature-ldexp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000004000000041000000" + } + }, + { + "id": "signature-ldexp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000" + } + }, + { + "id": "signature-atan2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atan2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atan2-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb" + } + }, + { + "id": "signature-atan2-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-atan2-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-atan2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atan2-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb" + } + }, + { + "id": "signature-atan2-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-atan2-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-atan2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb" + } + }, + { + "id": "signature-atan2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-arctan2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctan2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctan2-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb" + } + }, + { + "id": "signature-arctan2-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-arctan2-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-arctan2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctan2-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb" + } + }, + { + "id": "signature-arctan2-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-arctan2-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-arctan2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb" + } + }, + { + "id": "signature-arctan2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-pow-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-pow-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + } + }, + { + "id": "signature-pow-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + } + }, + { + "id": "signature-pow-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + } + }, + { + "id": "signature-pow-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + } + }, + { + "id": "signature-pow-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + } + }, + { + "id": "signature-pow-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + } + }, + { + "id": "signature-pow-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + } + }, + { + "id": "signature-pow-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + } + }, + { + "id": "signature-pow-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040800000" + } + }, + { + "id": "signature-pow-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004010000000000000" + } + }, + { + "id": "signature-extension-erf-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-erf-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-erf-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f57bb3d3f57bb3d" + } + }, + { + "id": "signature-extension-erf-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a" + } + }, + { + "id": "signature-extension-erf-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a" + } + }, + { + "id": "signature-extension-erf-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-erf-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f57bb3d3f57bb3d" + } + }, + { + "id": "signature-extension-erf-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a" + } + }, + { + "id": "signature-extension-erf-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a" + } + }, + { + "id": "signature-extension-erf-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f57bb3d3f57bb3d" + } + }, + { + "id": "signature-extension-erf-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a" + } + }, + { + "id": "signature-extension-erfc-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-erfc-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-erfc-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3e21130b3e21130b" + } + }, + { + "id": "signature-extension-erfc-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6" + } + }, + { + "id": "signature-extension-erfc-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6" + } + }, + { + "id": "signature-extension-erfc-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-erfc-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3e21130b3e21130b" + } + }, + { + "id": "signature-extension-erfc-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6" + } + }, + { + "id": "signature-extension-erfc-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6" + } + }, + { + "id": "signature-extension-erfc-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3e21130b3e21130b" + } + }, + { + "id": "signature-extension-erfc-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6" + } + }, + { + "id": "signature-extension-lgamma-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-lgamma-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-lgamma-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-lgamma-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-lgamma-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-lgamma-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-lgamma-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-lgamma-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-lgamma-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-lgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-lgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-tgamma-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-tgamma-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-tgamma-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f800000" + } + }, + { + "id": "signature-extension-tgamma-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000" + } + }, + { + "id": "signature-extension-tgamma-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000" + } + }, + { + "id": "signature-extension-tgamma-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-tgamma-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f800000" + } + }, + { + "id": "signature-extension-tgamma-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000" + } + }, + { + "id": "signature-extension-tgamma-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000" + } + }, + { + "id": "signature-extension-tgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f800000" + } + }, + { + "id": "signature-extension-tgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000" + } + }, + { + "id": "signature-extension-exp10-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-exp10-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-exp10-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4120000041200000" + } + }, + { + "id": "signature-extension-exp10-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000" + } + }, + { + "id": "signature-extension-exp10-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000" + } + }, + { + "id": "signature-extension-exp10-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-exp10-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4120000041200000" + } + }, + { + "id": "signature-extension-exp10-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000" + } + }, + { + "id": "signature-extension-exp10-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000" + } + }, + { + "id": "signature-extension-exp10-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4120000041200000" + } + }, + { + "id": "signature-extension-exp10-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000" + } + }, + { + "id": "signature-extension-sinpi-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-sinpi-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-sinpi-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-sinpi-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-sinpi-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-sinpi-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-sinpi-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-sinpi-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-sinpi-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-sinpi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-sinpi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-cospi-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-cospi-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-cospi-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000" + } + }, + { + "id": "signature-extension-cospi-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000" + } + }, + { + "id": "signature-extension-cospi-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000" + } + }, + { + "id": "signature-extension-cospi-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-cospi-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000" + } + }, + { + "id": "signature-extension-cospi-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000" + } + }, + { + "id": "signature-extension-cospi-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000" + } + }, + { + "id": "signature-extension-cospi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000" + } + }, + { + "id": "signature-extension-cospi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000" + } + }, + { + "id": "signature-extension-fdim-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-fdim-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-fdim-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-fdim-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-fdim-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-fdim-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-fdim-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-fdim-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-fdim-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-fdim-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-fdim-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-fma-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4000000040000000" + } + }, + { + "id": "signature-extension-fma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fac-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-fac-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + } + }, + { + "id": "signature-extension-fac-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "signature-extension-fac-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + } + }, + { + "id": "signature-extension-fac-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-fac-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + } + }, + { + "id": "signature-extension-fac-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "signature-extension-fac-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + } + }, + { + "id": "signature-extension-fac-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-fac-float32", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-fac-float64", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-ncr-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-ncr-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + } + }, + { + "id": "signature-extension-ncr-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "signature-extension-ncr-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + } + }, + { + "id": "signature-extension-ncr-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-ncr-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + } + }, + { + "id": "signature-extension-ncr-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "signature-extension-ncr-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + } + }, + { + "id": "signature-extension-ncr-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-ncr-float32", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-ncr-float64", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-npr-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-npr-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + } + }, + { + "id": "signature-extension-npr-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "signature-extension-npr-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + } + }, + { + "id": "signature-extension-npr-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-npr-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + } + }, + { + "id": "signature-extension-npr-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "signature-extension-npr-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + } + }, + { + "id": "signature-extension-npr-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-npr-float32", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-npr-float64", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-e-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-pi-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-where-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-where-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-where-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-where-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-where-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 51, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-where-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-where-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-where-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-where-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 51, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-where-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-where-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 51, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "exceptional-sin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f0599b3bf68c7b7bf576aa4bef57744800000000000000000000001008000003ef577443f576aa43f68c7b7bf0599b37fc000007fc00000" + } + }, + { + "id": "exceptional-cos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f5a5f96bed511333f0a51403f60a9403f8000003f8000003f8000003f8000003f60a9403f0a5140bed511333f5a5f967fc000007fc00000" + } + }, + { + "id": "exceptional-tan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f1c9eca400bd7b1bfc75923bf0bda7b800000000000000000000001008000003f0bda7b3fc75923c00bd7b1bf1c9eca7fc000007fc00000" + } + }, + { + "id": "exceptional-sinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff800000c0681e7bbf966cfebf056680800000000000000000000001008000003f0566803f966cfe40681e7b7f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-cosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f8000004070c7d03fc583ab3f90560c3f8000003f8000003f8000003f8000003f90560c3fc583ab4070c7d07f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-tanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf76ca83bf42f7d6beec9a9f800000000000000000000001008000003eec9a9f3f42f7d63f76ca833f8000003f8000007fc00000" + } + }, + { + "id": "exceptional-sqrt-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc0000080000000000000001a3504f3200000003f3504f33f8000003fb504f35f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-cbrt-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000d4cb2ff5bfa14518bf800000bf4b2ff5800000000000000026a145182a8000003f4b2ff53f8000003fa1451854cb2ff57f8000007fc00000" + } + }, + { + "id": "exceptional-exp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003e0a95553ebc5ab23f1b45983f8000003f8000003f8000003f8000003fd3094c402df85440ec73267f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-exp2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003e8000003f0000003f3504f33f8000003f8000003f8000003f8000003fb504f340000000408000007f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-expm1-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf5d5aabbf21d2a7bec974d0800000000000000000000001008000003f2612993fdbf0a940cc73267f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-log-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c2ce8ed0c2aeac50bf317218000000003f31721842b172187f8000007fc00000" + } + }, + { + "id": "exceptional-log2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c3150000c2fc0000bf800000000000003f800000430000007f8000007fc00000" + } + }, + { + "id": "exceptional-log10-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c23369f4c217b818be9a209b000000003e9a209b421a209b7f8000007fc00000" + } + }, + { + "id": "exceptional-log1p-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000ff800000bf317218800000000000000000000001008000003ecf991f3f3172183f8c9f5442b172187f8000007fc00000" + } + }, + { + "id": "exceptional-ceil-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000003f8000003f8000003f8000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-floor-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf80000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-trunc-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-rint-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-round-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-sign-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf800000bf800000bf80000000000000000000003f8000003f8000003f8000003f8000003f8000003f8000003f8000007fc00000" + } + }, + { + "id": "exceptional-square-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f800000408000003f8000003e800000000000000000000000000000000000003e8000003f800000408000007f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-conj-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf000000800000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-real-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf000000800000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-imag-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "id": "exceptional-isfinite-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000101010101010101010101010000" + } + }, + { + "id": "exceptional-isinf-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010000000000000000000000000100" + } + }, + { + "id": "exceptional-isnan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000001" + } + }, + { + "id": "exceptional-signbit-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010101010101000000000000000000" + } + }, + { + "id": "exceptional-fabs-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f8000003f000000000000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-absolute-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f8000003f000000000000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-abs-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f8000003f000000000000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-ln-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c2ce8ed0c2aeac50bf317218000000003f31721842b172187f8000007fc00000" + } + }, + { + "id": "exceptional-acos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc0000040490fda40060a923fc90fdb3fc90fdb3fc90fdb3fc90fdb3f860a92000000007fc000007fc000007fc000007fc00000" + } + }, + { + "id": "exceptional-asin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000bfc90fdabf060a92800000000000000000000001008000003f060a923fc90fda7fc000007fc000007fc000007fc00000" + } + }, + { + "id": "exceptional-atan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bfc90fdabfc90fdabf8db70dbf490fdbbeed6338800000000000000000000001008000003eed63383f490fdb3f8db70d3fc90fda3fc90fda7fc00000" + } + }, + { + "id": "exceptional-acosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc00000000000003fa8921442b2d4fc7f8000007fc00000" + } + }, + { + "id": "exceptional-asinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000c2b2d4fcbfb8c90cbf61a1b3bef66165800000000000000000000001008000003ef661653f61a1b33fb8c90c42b2d4fc7f8000007fc00000" + } + }, + { + "id": "exceptional-atanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000ff800000bf0c9f54800000000000000000000001008000003f0c9f547f8000007fc000007fc000007fc000007fc00000" + } + }, + { + "id": "exceptional-arccos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc0000040490fda40060a923fc90fdb3fc90fdb3fc90fdb3fc90fdb3f860a92000000007fc000007fc000007fc000007fc00000" + } + }, + { + "id": "exceptional-arcsin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000bfc90fdabf060a92800000000000000000000001008000003f060a923fc90fda7fc000007fc000007fc000007fc00000" + } + }, + { + "id": "exceptional-arctan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bfc90fdabfc90fdabf8db70dbf490fdbbeed6338800000000000000000000001008000003eed63383f490fdb3f8db70d3fc90fda3fc90fda7fc00000" + } + }, + { + "id": "exceptional-arccosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc00000000000003fa8921442b2d4fc7f8000007fc00000" + } + }, + { + "id": "exceptional-arcsinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000c2b2d4fcbfb8c90cbf61a1b3bef66165800000000000000000000001008000003ef661653f61a1b33fb8c90c42b2d4fc7f8000007fc00000" + } + }, + { + "id": "exceptional-arctanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000ff800000bf0c9f54800000000000000000000001008000003f0c9f547f8000007fc000007fc000007fc000007fc00000" + } + }, + { + "id": "exceptional-minimum-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000ff7fffffc0000000bf800000bf000000800000008000000000000001000000013f000000bf80000040000000ff7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-maximum-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000000000000000000000400000008000000000000000000000000080000000800000400000003f8000007f8000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-fmin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf000000800000008000000000000001000000013f000000bf80000040000000ff7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-fmax-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff8000000000000000000000400000008000000000000000000000000080000000800000400000003f8000007f8000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-hypot-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff40000000400f1bbd3f000000000000000000000000800000008000004003f07b3fb504f37f8000007f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-copysign-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f800000bf000000000000008000000000000001008000003f000000bf80000040000000ff7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-nextafter-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000ff7ffffebfffffffbf7fffffbeffffff000000008000000000000002007fffff3f0000013f7fffff400000017f7ffffe7f8000007fc00000" + } + }, + { + "id": "exceptional-logaddexp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003e01f96b40031c0e3ef2ba383f3172183f3172183f3172183f317218400ce3f53f903f2d7f8000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-fmod-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000bf8000007fc000007fc000007fc0000000000001000000003f0000000000000040000000000000007fc000007fc00000" + } + }, + { + "id": "exceptional-remainder-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000003f8000007fc000007fc000007fc0000000000001000000003f0000008000000040000000800000007fc000007fc00000" + } + }, + { + "id": "exceptional-power-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003e8000003f8000007f800000000000007f8000007fc00000" + } + }, + { + "id": "exceptional-ldexp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff800000bf800000bf800000bf800000800000000000000000000000004000003f8000007f8000007f8000007f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-atan2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000bfc90fdbbfc90fdbbeed6338bfc90fdb8000000040490fda340000003fc90fda3e7adbb04016cbe4000000004016cbe43f490fdb7fc00000" + } + }, + { + "id": "exceptional-arctan2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000bfc90fdbbfc90fdbbeed6338bfc90fdb8000000040490fda340000003fc90fda3e7adbb04016cbe4000000004016cbe43f490fdb7fc00000" + } + }, + { + "id": "exceptional-pow-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003e8000003f8000007f800000000000007f8000007fc00000" + } + }, + { + "id": "ties-rint-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c0800000c0000000c00000008000000000000000400000004000000040800000" + } + }, + { + "id": "ties-round-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c0800000c0000000c00000008000000000000000400000004000000040800000" + } + }, + { + "id": "extension-erf-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3e8d7aa73f053f7b3f57bb3d3f7ecd71" + } + }, + { + "id": "extension-exceptional-erf-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf7ecd71bf57bb3dbf053f7b80000000000000000000000100906ebb3f053f7b3f57bb3d3f7ecd713f8000003f8000007fc00000" + } + }, + { + "id": "extension-erfc-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3f3942ac3ef5810a3e21130b3b9947af" + } + }, + { + "id": "extension-exceptional-erfc-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "40000000400000003fff66b83febdd9f3fc29fbe3f8000003f8000003f8000003f8000003ef5810a3e21130b3b9947af00000000000000007fc00000" + } + }, + { + "id": "extension-lgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fa4ddec3f1286820000000000000000" + } + }, + { + "id": "extension-exceptional-lgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f8000007f8000007f8000003fa1fc4d7f8000007f80000042ce8ed042aeac503f12868200000000000000007f8000007f8000007fc00000" + } + }, + { + "id": "extension-tgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "406809fe3fe2dfc53f8000003f800000" + } + }, + { + "id": "extension-exceptional-tgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc00000c062dfc5ff8000007f8000007f8000007e8000003fe2dfc53f8000003f8000007f8000007f8000007fc00000" + } + }, + { + "id": "extension-exp10-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe39ea9404a62c24120000042c80000" + } + }, + { + "id": "extension-exceptional-exp10-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003c23d70a3dcccccd3ea1e89b3f8000003f8000003f8000003f800000404a62c24120000042c800007f8000007f8000007fc00000" + } + }, + { + "id": "extension-sinpi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3f3504f33f8000000000000000000000" + } + }, + { + "id": "extension-exceptional-sinpi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000800000008000000080000000bf80000080000000000000000000000301490fdb3f8000000000000000000000000000007fc000007fc00000" + } + }, + { + "id": "extension-cospi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3f3504f300000000bf8000003f800000" + } + }, + { + "id": "extension-exceptional-cospi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f8000003f800000bf800000000000003f8000003f8000003f8000003f80000000000000bf8000003f8000003f8000007fc000007fc00000" + } + }, + { + "id": "extension-fdim-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000003f800000" + } + }, + { + "id": "extension-exceptional-fdim-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc0000000000000000000000000000000000000000000000000000000000000007fffff0000000040000000000000007f800000000000007fc00000" + } + }, + { + "id": "extension-fma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "bf400000bf000000000000003f800000" + } + }, + { + "id": "extension-exceptional-fma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 180, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000000000000000000000c000000000000000000000000000000000000000000000003f800000bf8000007f800000ff8000007f8000007fc00000" + } + }, + { + "id": "extension-fac-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000060000000000000018" + } + }, + { + "id": "extension-ncr-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 64, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + } + }, + { + "id": "extension-npr-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 64, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + } + }, + { + "id": "extension-e-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b1457694005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "extension-pi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18400921fb54442d18400921fb54442d18" + } + }, + { + "id": "exceptional-sin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bf7452fc98b34e97bfed18f6ead1b446bfeaed548f090ceebfdeaee8744b05f080000000000000000000000000000000000000000000000100100000000000003fdeaee8744b05f03feaed548f090cee3fed18f6ead1b4463f7452fc98b34e977ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-cos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bfefffe62ecfab75bfdaa226575372053fe14a280fb5068c3fec1528065b7d503ff00000000000003ff00000000000003ff00000000000003ff00000000000003fec1528065b7d503fe14a280fb5068cbfdaa22657537205bfefffe62ecfab757ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-tan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003f74530cfe72948340017af62e0950f8bff8eb245cbee3a5bfe17b4f5bf3474a80000000000000000000000000000000000000000000000100100000000000003fe17b4f5bf3474a3ff8eb245cbee3a5c0017af62e0950f8bf74530cfe7294837ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-sinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000fff0000000000000c00d03cf63b6e19fbff2cd9fc44eb982bfe0acd00fe63b9780000000000000000000000000000000000000000000000100100000000000003fe0acd00fe63b973ff2cd9fc44eb982400d03cf63b6e19f7ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-cosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007ff0000000000000400e18fa0df2d9bc3ff8b07551d9f5503ff20ac1862ae8d03ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff20ac1862ae8d03ff8b07551d9f550400e18fa0df2d9bc7ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-tanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bfeed9505e1bc3d4bfe85efab514f394bfdd9353d7568af380000000000000000000000000000000000000000000000100100000000000003fdd9353d7568af33fe85efab514f3943feed9505e1bc3d43ff00000000000003ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-sqrt-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000800000000000000000000000000000001e6000000000000020000000000000003fe6a09e667f3bcd3ff00000000000003ff6a09e667f3bcd5fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-cbrt-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000d54428a2f98d728bbff428a2f98d728bbff0000000000000bfe965fea53d6e3d8000000000000000000000000000000029900000000000002aa428a2f98d728b3fe965fea53d6e3d3ff00000000000003ff428a2f98d728b554428a2f98d728b7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-exp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003fc152aaa3bf81cc3fd78b56362cef383fe368b2fc6f960a3ff00000000000003ff00000000000003ff00000000000003ff00000000000003ffa61298e1e069c4005bf0a8b145769401d8e64b8d4ddae7ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-exp2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003fd00000000000003fe00000000000003fe6a09e667f3bcd3ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff6a09e667f3bcd400000000000000040100000000000007ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-expm1-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bfebab5557101f8dbfe43a54e4e98864bfd92e9a0720d3ec80000000000000000000000000000000000000000000000100100000000000003fe4c2531c3c0d383ffb7e151628aed340198e64b8d4ddae7ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-log-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c0874385446d71c3c086232bdd7abcd2bfe62e42fefa39ef00000000000000003fe62e42fefa39ef40862e42fefa39ef7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-log2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c090c80000000000c08ff00000000000bff000000000000000000000000000003ff000000000000040900000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-log10-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c07434e6420f4374c0733a7146f72a42bfd34413509f79ff00000000000000003fd34413509f79ff40734413509f79ff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-log1p-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000fff0000000000000bfe62e42fefa39ef80000000000000000000000000000000000000000000000100100000000000003fd9f323ecbf984c3fe62e42fefa39ef3ff193ea7aad030b40862e42fefa39ef7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-ceil-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000003ff00000000000003ff00000000000003ff00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-floor-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bff0000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-trunc-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-rint-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-round-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-sign-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bff0000000000000bff0000000000000bff0000000000000000000000000000000000000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-square-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007ff000000000000040100000000000003ff00000000000003fd000000000000000000000000000000000000000000000000000000000000000000000000000003fd00000000000003ff000000000000040100000000000007ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-conj-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-real-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-imag-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "id": "exceptional-isfinite-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000101010101010101010101010000" + } + }, + { + "id": "exceptional-isinf-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010000000000000000000000000100" + } + }, + { + "id": "exceptional-isnan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000001" + } + }, + { + "id": "exceptional-signbit-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010101010101000000000000000000" + } + }, + { + "id": "exceptional-fabs-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff00000000000003fe000000000000000000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-absolute-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff00000000000003fe000000000000000000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-abs-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff00000000000003fe000000000000000000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-ln-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c0874385446d71c3c086232bdd7abcd2bfe62e42fefa39ef00000000000000003fe62e42fefa39ef40862e42fefa39ef7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-acos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000400921fb54442d184000c152382d73663ff921fb54442d183ff921fb54442d183ff921fb54442d183ff921fb54442d183ff0c152382d736500000000000000007ff80000000000007ff80000000000007ff8000000000000fff8000000000000" + } + }, + { + "id": "exceptional-asin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff8000000000000fff8000000000000fff8000000000000bff921fb54442d18bfe0c152382d736580000000000000000000000000000000000000000000000100100000000000003fe0c152382d73653ff921fb54442d187ff80000000000007ff80000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-atan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff921fb54442d18bff921fb54442d18bff1b6e192ebbe45bfe921fb54442d18bfddac670561bb5080000000000000000000000000000000000000000000000100100000000000003fddac670561bb503fe921fb54442d183ff1b6e192ebbe453ff921fb54442d183ff921fb54442d187ff8000000000000" + } + }, + { + "id": "exceptional-acosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff800000000000000000000000000003ff5124271980434408633ce8fb9f87d7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-asinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000c08633ce8fb9f87dbff719218313d087bfec34366179d427bfdecc2caec5160a80000000000000000000000000000000000000000000000100100000000000003fdecc2caec5160a3fec34366179d4273ff719218313d087408633ce8fb9f87d7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-atanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000fff0000000000000bfe193ea7aad030b80000000000000000000000000000000000000000000000100100000000000003fe193ea7aad030b7ff00000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-arccos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000400921fb54442d184000c152382d73663ff921fb54442d183ff921fb54442d183ff921fb54442d183ff921fb54442d183ff0c152382d736500000000000000007ff80000000000007ff80000000000007ff8000000000000fff8000000000000" + } + }, + { + "id": "exceptional-arcsin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff8000000000000fff8000000000000fff8000000000000bff921fb54442d18bfe0c152382d736580000000000000000000000000000000000000000000000100100000000000003fe0c152382d73653ff921fb54442d187ff80000000000007ff80000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-arctan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff921fb54442d18bff921fb54442d18bff1b6e192ebbe45bfe921fb54442d18bfddac670561bb5080000000000000000000000000000000000000000000000100100000000000003fddac670561bb503fe921fb54442d183ff1b6e192ebbe453ff921fb54442d183ff921fb54442d187ff8000000000000" + } + }, + { + "id": "exceptional-arccosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff800000000000000000000000000003ff5124271980434408633ce8fb9f87d7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-arcsinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000c08633ce8fb9f87dbff719218313d087bfec34366179d427bfdecc2caec5160a80000000000000000000000000000000000000000000000100100000000000003fdecc2caec5160a3fec34366179d4273ff719218313d087408633ce8fb9f87d7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-arctanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000fff0000000000000bfe193ea7aad030b80000000000000000000000000000000000000000000000100100000000000003fe193ea7aad030b7ff00000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-minimum-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000008000000000000000000000000000000100000000000000013fe0000000000000bff00000000000004000000000000000ffefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-maximum-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000000000000000000000000000000000000040000000000000008000000000000000000000000000000000000000000000000010000000000000001000000000000040000000000000003ff00000000000007ff00000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-fmin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000008000000000000000000000000000000100000000000000013fe0000000000000bff00000000000004000000000000000ffefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-fmax-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff00000000000000000000000000000000000000000000040000000000000008000000000000000000000000000000000000000000000000010000000000000001000000000000040000000000000003ff00000000000007ff00000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-hypot-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000004001e3779b97f4a83fe0000000000000000000000000000000000000000000000010000000000000001000000000000040007e0f66afed073ff6a09e667f3bcd7ff00000000000007ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-copysign-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff0000000000000bfe000000000000000000000000000008000000000000000000000000000000100100000000000003fe0000000000000bff00000000000004000000000000000ffefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-nextafter-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000ffeffffffffffffebfffffffffffffffbfefffffffffffffbfdfffffffffffff000000000000000080000000000000000000000000000002000fffffffffffff3fe00000000000013fefffffffffffff40000000000000017feffffffffffffe7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-logaddexp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003fc03f2d54301d4940006381c3f0115c3fde5746fdb5c0643fe62e42fefa39ef3fe62e42fefa39ef3fe62e42fefa39ef3fe62e42fefa39ef40019c7e908f54213ff207e5aa8603a97ff00000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-fmod-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000bff00000000000007ff80000000000007ff80000000000007ff8000000000000000000000000000100000000000000003fe00000000000000000000000000000400000000000000000000000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-remainder-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000003ff00000000000007ff80000000000007ff80000000000007ff8000000000000000000000000000100000000000000003fe00000000000008000000000000000400000000000000080000000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-power-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003fd00000000000003ff00000000000007ff000000000000000000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-ldexp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 180, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000fff0000000000000bff0000000000000bff0000000000000bff000000000000080000000000000000000000000000000000000000000000000080000000000003ff00000000000007ff00000000000007ff00000000000007ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-atan2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bff921fb54442d18bff921fb54442d18bfddac670561bb4fbff921fb54442d188000000000000000400921fb54442d183cb00000000000003ff921fb54442d173fcf5b75f92c80dd4002d97c7f3321d200000000000000004002d97c7f3321d23fe921fb54442d187ff8000000000000" + } + }, + { + "id": "exceptional-arctan2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bff921fb54442d18bff921fb54442d18bfddac670561bb4fbff921fb54442d188000000000000000400921fb54442d183cb00000000000003ff921fb54442d173fcf5b75f92c80dd4002d97c7f3321d200000000000000004002d97c7f3321d23fe921fb54442d187ff8000000000000" + } + }, + { + "id": "exceptional-pow-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003fd00000000000003ff00000000000007ff000000000000000000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "ties-rint-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 64, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c010000000000000c000000000000000c00000000000000080000000000000000000000000000000400000000000000040000000000000004010000000000000" + } + }, + { + "id": "ties-round-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 64, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c010000000000000c000000000000000c00000000000000080000000000000000000000000000000400000000000000040000000000000004010000000000000" + } + }, + { + "id": "extension-erf-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fd1af54e232d6083fe0a7ef5c18edd23feaf767a741088a3fefd9ae142795e3" + } + }, + { + "id": "extension-exceptional-erf-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bfefd9ae142795e3bfeaf767a741088abfe0a7ef5c18edd280000000000000000000000000000000000000000000000100120dd750429b6d3fe0a7ef5c18edd23feaf767a741088a3fefd9ae142795e33ff00000000000003ff00000000000007ff8000000000000" + } + }, + { + "id": "extension-erfc-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe728558ee694fc3fdeb02147ce245c3fc4226162fbddd63f7328f5ec350e65" + } + }, + { + "id": "extension-exceptional-erfc-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "400000000000000040000000000000003fffecd70a13caf23ffd7bb3d3a084453ff853f7ae0c76e93ff00000000000003ff00000000000003ff00000000000003ff00000000000003fdeb02147ce245c3fc4226162fbddd63f7328f5ec350e65000000000000000000000000000000007ff8000000000000" + } + }, + { + "id": "extension-lgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3ff49bbd81c16efb3fe250d048e7a1bc00000000000000000000000000000000" + } + }, + { + "id": "extension-exceptional-lgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007ff00000000000007ff00000000000007ff00000000000003ff43f89a3f0edd67ff00000000000007ff000000000000040874385446d71c34086232bdd7abcd23fe250d048e7a1bc000000000000000000000000000000007ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "extension-tgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "400d013fc47eeeea3ffc5bf891b4ef6b3ff00000000000003ff0000000000000" + } + }, + { + "id": "extension-exceptional-tgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff8000000000000c00c5bf891b4ef6afff00000000000007ff00000000000007ff00000000000007fd00000000000003ffc5bf891b4ef6b3ff00000000000003ff00000000000007ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "extension-exp10-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3ffc73d51c54470e40094c583ada5b5340240000000000004059000000000000" + } + }, + { + "id": "extension-exceptional-exp10-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003f847ae147ae147b3fb999999999999a3fd43d136248490f3ff00000000000003ff00000000000003ff00000000000003ff000000000000040094c583ada5b53402400000000000040590000000000007ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "extension-sinpi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe6a09e667f3bcc3ff000000000000000000000000000000000000000000000" + } + }, + { + "id": "extension-exceptional-sinpi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000800000000000000080000000000000008000000000000000bff0000000000000800000000000000000000000000000000000000000000003002921fb54442d183ff00000000000000000000000000000000000000000000000000000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "extension-cospi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe6a09e667f3bcd0000000000000000bff00000000000003ff0000000000000" + } + }, + { + "id": "extension-exceptional-cospi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003ff00000000000003ff0000000000000bff000000000000000000000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000000000000000000000bff00000000000003ff00000000000003ff00000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "extension-fdim-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 64, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "extension-exceptional-fdim-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000fffffffffffff0000000000000000400000000000000000000000000000007ff000000000000000000000000000007ff8000000000000" + } + }, + { + "id": "extension-fma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "bfe8000000000000bfe000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "extension-exceptional-fma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 360, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ff0000000000000bff00000000000007ff0000000000000fff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "extension-fac-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000060000000000000018" + } + }, + { + "id": "extension-ncr-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 64, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + } + }, + { + "id": "extension-npr-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 64, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + } + }, + { + "id": "extension-e-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b1457694005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "extension-pi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18400921fb54442d18400921fb54442d18" + } + }, + { + "id": "extension-domain-fac", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "extension-float-reject-fac", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "extension-domain-ncr", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "extension-float-reject-ncr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "extension-domain-npr", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "extension-float-reject-npr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "where-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000080000000" + } + }, + { + "id": "where-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 51, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000008000000000000000" + } + }, + { + "id": "status-invalid", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000" + } + }, + { + "id": "status-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000" + } + }, + { + "id": "status-overflow", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "7ff0000000000000" + } + }, + { + "id": "status-underflow", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "status-clear", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "4000000000000000" + } + }, + { + "id": "status-lazy-where", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000004000000000000000" + } + }, + { + "id": "arity-reject-sin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-cos", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-tan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-sinh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-cosh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-tanh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-sqrt", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-cbrt", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-exp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-exp2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-expm1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-log", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-log2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-log10", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-log1p", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-ceil", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-floor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-trunc", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-rint", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-round", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-sign", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-square", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-conj", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-real", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-imag", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-isfinite", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-isinf", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-isnan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-signbit", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-fabs", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-absolute", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-abs", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-ln", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-acos", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-asin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-atan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-acosh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-asinh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-atanh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-arccos", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-arcsin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-arctan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-arccosh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-arcsinh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-arctanh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-minimum", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-maximum", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-fmin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-fmax", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-hypot", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-copysign", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-nextafter", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-logaddexp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-fmod", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-remainder", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-power", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-ldexp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-atan2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-arctan2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-pow", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-erf", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-erfc", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-lgamma", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-tgamma", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-exp10", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-sinpi", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-cospi", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-fdim", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-fma", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-fac", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-ncr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-npr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-e", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-pi", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-where", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "spelling-reject-float-power", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "spelling-reject-logaddexp2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "spelling-reject-heaviside", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "spelling-reject-spacing", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "spelling-reject-frexp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "spelling-reject-modf", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "certified-sqrt-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40105d8e3ff2010b3ecf06eb402b212f3ff09d163fe26b5240052a793fc89d8940094087402a03843fd056e640081a6f4011d2013f527df7402d1e95401dc1023ee6007b3f77ac403f56292b3fcc07a13fd0fb0340209ffd3f96db6140208f4d4006bada4007ec5f3faeabf0403007b5401c56354000d47540022247401acaf5" + } + }, + { + "id": "certified-exp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f813d1b3f8724c5400a58663efbef813f021fd23f8bff413fd7959b3fd3a1073f31e89b3f949bd43ffad1273fbdc30c3f990fb83fb445c63fdbfc353f0b765e3fe8b0683ff53f703fdd4cbf3f4684193f9764853f07d5803f628dd73f9e3c783f629c443fc238073fbeffb93f29bcba3f80e7873f0ca8073fc19f063fb29f08" + } + }, + { + "id": "certified-expm1-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "be99f8f43f4b334ebf0b574c3eaf7a75bf0b8cf6befbbd9cbf05a2c5be9022ae3eee010bbeff6c3a3f6d3fba3f903ffd3e82c68bbe8d6c773f8d6a963f36f312bef50acdbe3b52e03f176d523f76d5a23f15f6843e0e132dbe95f42b3f512cdd3ed1ae9bbecaecf13f8c7b4abe2378ca3e5780633e1b9c663e32de9e3f16c859" + } + }, + { + "id": "certified-log-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fafe8f73ff051663fe8309c3f9c33913fa598c43f6f69533fd0c91e3fefd8e83fcca67c3f95f94f3f0cd4e64001742f3e0a2e773f40a9e5be92c2603fd1d8c73febe7663f5806323fad18363f94eaf23fe3f8513fcf36633febb32f3ff32fa43f9828023fc67ff13ff003183ea6670f3fdf163e3fe3b66f3ebe29e2bfa442fa" + } + }, + { + "id": "certified-log10-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f08c0d63f4acee6bf1f75c83f46cce8bd2c6ac93f38283c3f2ab4dc3f21116f3f0ab6c43f44775d3f1a04403f3769133f567652bf1f26aa3e4fa7463deb93b73f6097b53ea1f5243e28fe833f3cbbee3e66b61c3f3ae929bf09f95f3ed428cb3f5f70d73f65912a3f47a33d3cc44de43f33cc2e3f57eb023f50d38b3f3e5993" + } + }, + { + "id": "certified-log1p-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bec18fd5be23a284bf8db1b33eac6b8c3eace35f3ef04f89bc50e3e9bee7d0843e48c7d73f0b614ebfc75e6abf429ca43de9c11a3d617799bd7b0ade3dd410a9bfb47cf3be9bb5923ea9cd773f04c2e6bf280d26bf57e827be1c0b913ecfe6abbe7170e63d5195f43e3231d1be2c1ff6bd92560ebfb68558bd5aed57bed5785b" + } + }, + { + "id": "certified-sin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e90b434bd93cbad3e745e673a8e77e3bea240cc3effe444bee149fbbeb64be53c8a0b30bf0abcbabe6fe597bf1b47bb3ed2427dbf33ad98bf27578fbec8fcdfbb8b6562bf189be33ea17b4e3e5652be3e8a85acbd45b842bf1e487b3ec9e6c6bda90f2fbf292d0c3eae305c3eb898643f051468bf04cf77bf14b4febf03c68b" + } + }, + { + "id": "certified-cos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f7ffc033f549cb03f36b8743f4a6b463f78c57f3f7f3b753f758c0d3f6469513f7cb6903f76d5893f78af4f3f7ae0ab3f7a31a73f7ffa373f64356c3f7b94d63f775ff03f7d1cc63f6686d63f55e1c93f7ebde53f6963293f731fc63f5e5a1d3f62cd723f61fbb93f5e56973f7a4b6f3f5a452c3f7ef69a3f7eaa013f3b994c" + } + }, + { + "id": "certified-tan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf30792c3f65c7803edf6621bf8355d03e9afa1dbf791bce3edc2a0a3e2f94c43d5873113e1f804abe5a0dc2bf3193dc3e98c6c2bf4ca6583f82324bbb8a28ef3f275a773f4326f13e31309e3f0c324bbf6de3d03f0ca5193ebb7082be805cea3e852f92bf1312e1bf7ad958bdc0b60cbe93b2f1bf4750b6bf468002bf465ec5" + } + }, + { + "id": "certified-asin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf57cf763f16650f3e9c1ac03ed0a6d23e9b73f3bf54dda4be4407c9bd14b5d8be762717bedafdaabdd008d0bf1d0c2d3e164435be8fe9773dfc59ecbe1f07ce3f64240b3e95412fbf36d9df3f16a82a3f157edc3f2e35613e55b1163e6949163e9751483e6c99f73f0e7ef9be759bd8beba52e93e611600bef00540bf177f14" + } + }, + { + "id": "certified-acos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fd864ad3f5e6b673fa71a313fd0fa073fcbc77b3f6e78143ff7690f3f5ad1683f9bc89c3f9d0b523fbe26424014a2a43f6f65e74005c02e3fab4fbb3fd4e6e63fa3d8ca3f414538401f2a223f3a9d423f4c17e33f70ef8b3f8d22be3fa64f993f9981b63fbd09303fd54980401afacd3fe8cbbe3f91903f3f5182923fb0a6f8" + } + }, + { + "id": "certified-atan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf2c528c3e9d6ce63f02d22abe03a07c3f1783233ec846ba3f19d5fd3eca6df7be5fc6f63f110bdbbf229731bea656e83d8d290e3ee2c7e7bc47f180bedb39583f0d01e23ddd9ba6bf066206bf2980dcbe02e65abe82f820becd09d2be4e8b80beb3cad03e99a332bf12aba73eaf3775be5f93f83e2acf9dbe002c343ef5e556" + } + }, + { + "id": "certified-sinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f5e67963ec641a43f36285bbefde3f43ee8406e3e74d40f3f0af65abf4f1bc73f526aa0be2e41183f624160becbfaaebe5159273f446ed33e77910a3f1601d13e50d35dbf2d092f3ef6de40be84aea03dd3a80a3f14dd47bf547d9c3e53e7f53db02e5f3e247052bf5c04bbbf197828bf08250fbf305c0bbf24ff733ee7c75c" + } + }, + { + "id": "certified-cosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f850fee3f847be43f875e3e3f8159d33f97e6383fa6528c3f88ba3b3f825e883f9893bb3f807f8d3f84d87b3f815ec63fa726473f900dbc3f80ea4e3f8aea283f9004683f83ccb83f8499203f9ad3673f80f49d3f8066df3f9750c23f8505063fa6070c3f96ba803f9e098f3f81af843f8029073f8dbdf13f80f7953f80577a" + } + }, + { + "id": "certified-tanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e61ef53beb515ee3e3e0d81bed252c53ef504753e0e8383bf0396abbf1668603eb280033f1406413f03d769bee9ae563ea7721b3e5a6419be54f5663d8c83573eddf2053f276c54beda11d3bf219dbb3dfd0be1be914fcc3ec970a3bef5845dbf2218f53eef8b633f18275bbd4593fbbe8110533ed690fcbf24e159bf019fef" + } + }, + { + "id": "certified-asinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "be9b06b1bef70d09be968df83e9367ed3f212b50be8ed979b981e86ebe8b485cbedb1637becce82ebf0137bf3eb576133f1dfa6dbf06fd35be7ba7133ed7c179bdef7f113db56790be14b300bedea40ebe244b6bbed0b831be9620a03e8fa4dbbf17a1813f3866c4bf005be6bea358ecbeaa1f6dbe457a733ec121583e81dc52" + } + }, + { + "id": "certified-acosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "401a177d4024e7354023e0cc40036ad03f982fe14008133a3ffcd4773ffe9df03fc93bca3f7b0d013fccdc4b3fc3048b3fd1d2453fa0bce53ed4bdb83fbded193fe6639740236d773fb4063e3fd8616d400ceae73fa7414e401a6a9c401577bd40279a9d3fcc276b3ff8706d3fafb6c040224e313ec2598c40231b8a400ad9a6" + } + }, + { + "id": "certified-atanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e8632dbbe22c68d3ef507d3bf2b250d3ed9a0a73e6a4923bf7ac3c53e375387bd614dea3ebcdfe53e8d8f39bdbbd68dbee6c7793f39bf903f1f138d3d013735bd1c33e8beb4d316bf86c132bf822bf13e48a0343ee52d85bf2681923f5505b03f4738043edddf963e2ccd813f155747bf524b85bed4bec73f1c2adfbec9421d" + } + }, + { + "id": "certified-erf-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf0481ee3f35d43d3db7b4353f08ffedbec9f49a3f0d8e8d3edb1f043f3516563de04e4dbf37abf23f3df04b3e1a4cc23ea96917bee4b4683babff19bf09b686be7d2dd6bec00a8ebee892063efb4f063f0e5e073f3b055ebec53f993e3f0f9b3f3149b63dd54fbabeeb0d3d3f276090be309378be6fe1933f1ae877bf243d28" + } + }, + { + "id": "certified-erfc-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f3a00b83edbb9613fae6a543fbf4cd13f1426ef3f9dfc7e3f88e5b83f74b6583f60dc213f6380c43ea1734e3fd9323a3f6b053e3ead882c3f169dc63f21f8583f912fd03fbfeeae3fb5fe003fa61d9d3f1534933fdd6e283f8cd1ce3f955c323e914fa23fa74f383ee06dcb3f146ee03fb401503ef744c53f5b0c993fc28ab9" + } + }, + { + "id": "certified-sinpi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f44d2a2bf67b1083f29c6c9bf6282b8bf7dc236bf7ef96d3ed93ff1bf3792cdbee57bb4bf7ed6ea3e6985913f11af743f5379d2bf66ad293ec23b573f5751713f1ec5363f78c2cb3f754e1ebf586036bf12f3e23f451781bf7856fe3f35d6733f5434813f08f5dbbf55a835bf7dee8ebf273d463f7fc0643f42a7943f78ead0" + } + }, + { + "id": "certified-cospi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e9c8c0cbe4d19ae3f778d8c3f4d93833f6bc1f1be5ebe87be07aa643ec95cfbbe9d0ef23f65ec413f30f05e3f36e9e83eeb69293f7fb5553f719ebbbf065be1bde9b67fbeb5c0653e3c8bd7bf1492a4bec8c5b43ed65d683f5418e6be6b979d3f750f8bbedb1f90bf2503ce3f72f63f3ead62163e35305dbd74f210bf425070" + } + }, + { + "id": "certified-exp2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f993ed43f1e63e93f21ce3c3fdc0c183f17c5033f5ff2333f9782de3fab9aef3fd878773f6b98893f7cc71d3f32587e3f581f0c3f5613a63f615cf03fa547363faf26f53fcbf4933f847a913fd919843faa474c3f1328413f9dea4f3f4bf0d83f870d1d3fbcc4713f6c28fd3faff87e3fb3e2133fba420c3f975eb33f9034b7" + } + }, + { + "id": "certified-exp10-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e5cca2f3f1dc935406d14363f000b3b40c8fb9e3e2ead5c3e49fb6a3ea0f4113fa72d233e6369dc3e96418d3f1cd5733ff79dcd40a842b43f2196453fbc911440113d4a406fdfcf3e43aa193f4e57fe409516d53e89a906409953813f7b399f3f6cfe393e87b3793e2859da401d521c3ee799c23e3823e83ec17816407646a7" + } + }, + { + "id": "certified-log2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40285017bf0d0acb4034f09d402369d73fe2ac103f06a682401d431a40067a4c4014d7e6beb430f7403177903fd607f340144756402f1afc40183fbb4023809e3fd0073e3f6061a23f047c54403cd7143f2042d33f2785033fec2170bec717773fdb10453ff69f8a3ff954fb403e39de3ff09122bf582e074024500abfd365d2" + } + }, + { + "id": "certified-cbrt-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf1a50aebf3f30bdbf3b696cbf4f80403f447bbebf661625be6f01043f2bb0203f4fa4393f680a1ebf482bc3bef443c5be864d4c3ecb2526bf62cbf8bf35de08bf1feda5bf536884bf222f8ebf51df5a3f6c3ba8bf6d0993bf2cf6643f4f32f0bf4ec8353f66610dbf286d53bf4f03df3f462ae13f6823f3bf046a873e9c06e5" + } + }, + { + "id": "certified-lgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "405195ff404e573c3fa2166140b9658abc81d4684105e9414064196740768a713f80c67540c4b30c40eb493ebdebfc9340a07de940cacb443fcdeb503f9e1b9e3f63661240af7d69400dad203f96792abdf8cd21410259f940f5b4db4025b71bbded74833c27b0fc402ea56f40ee5eac3e25b85a3fd9038e3d820a313ff0ddc9" + } + }, + { + "id": "certified-tgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "4481d56e41bb56283f67f9b243d99468411f928e4095a5bc408195c7412edc6344ec102c41ca2e2a426996ce3f7daec2421be1af42beb0da40841a8442c4c01f41d24f9b445fde7a44610723402d598242efcf234048675d4273b12d4312ea89458674664215f82140d1777a402af16a40385ffc437cdbc83f64bfaa3f69efb4" + } + }, + { + "id": "certified-hypot-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40843bab40ca83cc407bc72d4076ada23e84650d40879d063f8ff1ec4091f9b640de2dfd40c58bde40b9130940a285f640dfe1c44082ea4b4083e1023feae4a840111eb04053289740e78e87404a6b12409f0bbf3fd3789740df201040a8426f4006f0904021a315400113f940e867c73f42ea393f5cf8da3fef896d407d0411" + } + }, + { + "id": "certified-atan2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "be8590e4bded1ffd3daa93ea3d4be5ebbeb8aca8be693288bd8083003de40e013dbb097c3f1aea43bd0ea23fbdac6ca73dd733933d1be51ebb1f85d9bd56e947bd47a1613e2924743dab71a1bcabbbc8bd3d016e3dced4373ee94bf2bbfba658bca54aec3ce1a724bf1ab09e3a7cd97cbe67d01f3d342a36bd1b663fbdb66c4d" + } + }, + { + "id": "certified-logaddexp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40f8c9e63fb8ae2e40456765407b59fc40eb52c640e3b3e940c261f940f0da7840055d98409eccc04095d07040da7a4b40f5ca44406fd07341004f1140d7bebc40f3554740e8dafe4055e03640f594cb40f35f944048ee1a40afebd740e5fbc240d9db2a4106f1194053c3b640d01e174064afd140ba4a8b3f62e44f40f6fdaa" + } + }, + { + "id": "certified-fma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 384, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "400e6b73c07aeaeebe95c3ff3fa60e26c06006503fcd0f8fbf6b0a0d3f9db340409b1b6ebfb86cecc0920af5c0b2bb44c0110ababec3a464403c5ee8bfaaf170c0305e573f000441bf509ca0c098de0a401c05004004ac56bf96e38ebea14e4ac09987e1beb4c83bbecf9c83bf935e9cbe72b635bfeb93913fb0b9d23f72011c" + } + }, + { + "id": "certified-sqrt-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40003be8662a5fb43ff17d28dc1939d73fe623ff8594f5134005f50bdba3cfa540022734b7acbe413fe5dab668b3126a3ff8830c80c000c040047d7528c7308c4000a5a085a5fb6f4003aa06c7aa116b3ffb8df4e0636edf400461bc406b5b363ff433e1a470ddd33fffd91365146a303feef157252cefb23ff69d2c9bd4e8b04003d54ef6f2cc214002b56471febdfa3ff8c777799bd1bd3ffa5d1df156e0c74003b8210119791d3ff75d4ca9afac9b400553f493d117e84001a2b63ee8e1304002f7e74f1b86423ff94ecafd04225b40020f39e7bb6d354003e2f7546ef0b93fe795aa4a607a703ff75fec854d201840063eb18a3c0e433ff5d9e8925f837c" + } + }, + { + "id": "certified-exp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe8cf9f96d70f593fde973644f9fe663fe22892e4bd6fc83fde2afb2405f5ca3ff4f3ad24acf3543ff276fc441d4c7e3ff85b2c3a62884a3feb1d51a7be45183fe0580d424f06d03fe2856852b6b2cd3ffc56e39ce7883b3ff4e7d08112b6323fe180894c24ec303fe24ba3156c25403fea5c9f5478a61c3ff3fb0072939be53ffbac769a77e3c63fdd6bdb37e5f93b3fe21f21ef5347f13fe8316adbad314a3fe6287f6861891240013928063665063ffc58e0be6f4dcf3ff9d3d50b310ddc3ff1aac8b1af41583fdf70d2db4edc263ffbc07c126f951e400107d1869c407f3ff483a8ce871ec53fe14ee49e5fc72e3ff2e0c8c04ac3cc3ff56f7c46e28ebc" + } + }, + { + "id": "certified-expm1-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe9994f99c2353d3fe0f0dd923a55c23ff0ff0acbbbdde43fd6ce5ec8f5a963bfd3ee3010b035433fe4d1b06cf9a6b9bfd7a42be64b6b2fbfc35e481f8c8c983fdf05ecaf28cd293fc9c3121379f2df3ff199b6b52859223fc1007234619bda3fdc8d4918a2b58b3ff12e4c166a19063fc9551cc084b1153fe794bae832df62bfd1f36036d8c761bfe16d612e0b56eebfb59b8e79fa3f573fd60de7116536a8bfe0276d018418023fc3007f6f9e1eb6bfc53c8b9bcb70bbbfce7a377a90754c3fd9db676c58b1fcbfd5c651af351a4ebfde5c9d5569fe61bfdf5cd019caaa56bfdf6ebcefe3569c3fa00d1d7526dc44bfd1f9ab36007df8bf7a57d512bdefd5" + } + }, + { + "id": "certified-log-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffbfdba27e447593ff3b55a0f5454153fff592f8c5ba6b53ffcf225e992e8273ffa320b51a1a8cd3ffa319b87b6396b40005046b8575b764000159cf0870b7dc0013c869a3ce87d3ff643b42dbf22d3400090ed49d4c7233ff208ea175be4e33fe6389c0dc8ccb9bfe5cefd96631f053ff9533cd948d2cf3ff3827c220bc4333fb3c2c074d326e93fd349eb0c10fc893ff53c0c5f54b4af3ffe1549a786d979bfe16a78239041763ffd3a0d5b12531c3ff4b556378365453ff97930157530a93ff7ee65ad2306eb3ff874f431d61d773ff22cd5bb5d03dd3ff15a62aa91d2d83ff537ecd46687053fddf8e68cd2f7a63feedc8fea7679ec3ff884ddcb1ba4a9" + } + }, + { + "id": "certified-log10-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe758a636fe51e73fe5002664c1db7f3fece4c1c8b1d4a33feade0934d8c1ed3fe41f1044d168553fd0aa1642ea02623fe0aa839c8cb9693fe6a48e374c63693fe4c5531621d8183fd4f853951fde483fe623f9b0290cfe3fd8a019b3d537083fb1a7987ccf6f9d3febe97e41dcbc8c3fe298b3bf9545643fe4960c8c2fc32c3fe82e1df671dfa93fe60d9f6a208e7d3fc61053c258b7f93fe68ddf0bfc706c3fd70e04133f25493fe31b1462690adc3fec139cbc73a2aa3fe9cd9f705cfa683fec1a84550ef3873fec4180205cb59c3fd9d8c6e2afdcb43fec455099710ba43fce6ce02ea308463fea8817fc28b2b5bfd3b93549806d513fdb2774a4544804" + } + }, + { + "id": "certified-log1p-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfc1e43d085cb220bff13126bea0a058bfaff5c51259f2493fddf06fbac80775bfe9fd5d586aa21fbfc4e81a78f39a3dbfedcdb22b08e4153fd47d4aed5dbf5a3f93f360310ae91e3fadf3db18443cc03fae723753b0ff01bfee8d2f0bdfe0c33fd71745a00d8fcfbfed4f9c20edf5403fc59e24761b9d73bfb444cefe38a0d9bff03696740d7437bff8c0d16edfdfb43fc5dbfcde040cb53fd43d31524b5f74bf742f939938c3c73fd39cf310c8f106bfbd8d5a8e30f6593fe1b8406a2e69413fbea632ede9ca833fe1f038a8ee9d81bfea7403198a5e67bfd9a31cb26494e23f92b7abb69900d0bfe710ab762b4596bff512711a21f5813fdf55b3093c2b57" + } + }, + { + "id": "certified-sin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfd647eab328f2ecbfe6291ae1148e213fe1a935f0b136a13fd7395ed31883f2bfdd4c30aefa15f83fd18b3b83f4ee9abfe0ea4d243841083fc65359928d381c3fe0775a321b6625bfe16fabcb340447bfc9f585059082f5bfd48a739e28ad193fe67824a911a33abfe2f08f76520d683fd480b6f8de53d53fc50739e7392bcc3fe2187a52fd65e93fd8fc770f947e4c3fb83164779f5b273fdf9fa6fc91e5933fe1bae938ef4e31bfd709a0d77e44163fcbe6e3f98944333fe4e22af1f74dfbbfe361d961d2b456bfd2c5038afd99213f966d5f53d18531bfdad2d4a1ae6425bfda0b58126e6e823fd556e30c7a50b1bfe48c22be57217f3fc9654224c13bdd" + } + }, + { + "id": "certified-cos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fec927e8d46bd4b3fe8cf43dedb55613fedcd55b454550b3fed448cabf4b6ca3feeb77e3de6f2f23fe946cad1c8d39b3fe99307eb9a2e593febc9455c4b8fd63fecc39afe638a0a3fee67362375dd503feb75d227f50f123fe89917254c41f53fefe6644a10bcd63fee1243c57839783fe668f376c1364a3fee1d1a98482dab3fee9fa15fb834293fefa3af114ce1153fe9b9c72c65eef33fea18fe77eec69c3fef24afa878db383feff53821de16ff3fe83fab5ac1eb383fecbd9be970c7fa3fee2a8f36ed48443feb8e6f2f4a57933fec9dcc5b9693533fe7edc621a534c13febe5867a0d93873feea1f95b38e9843fe9b8a67f0593403fec0670b4fa43b7" + } + }, + { + "id": "certified-tan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fbc22a4754c7723bfbb2ff162f7e1ef3fe484c5c4e68cd73fea6066615a78bdbfd9e3fa24aa753c3fb6e718eba13806bfd585aba0dfae343fd13e1b2e534f55bfa0135db053c7023fe0a0d0009ed35fbfe065a708874beebfe9cba2fd5cdb093fe2bcaace7746703fefd6ff78539a75bfd6860f77880102bfe9d755ac77151dbfe14d5596872181bfc198e97bdb60a8bfb3609f435fbc943fb547c23964e4d53fe8e026bf1d6baabfb1eb131a7c1725bfd2568d655e7e673fed17dc7dcd2d003fd8d1e28a25cd9d3fa175cf4d0c4df23fc99e524e62d1b4bfe6be39de491c91bf9d1021a344d8263fe2a944f2b2666b3fa57208eca541be3fe4f5a32f3b728a" + } + }, + { + "id": "certified-asin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfcdeb737886df7cbf9434bbf155299dbfe2fcea06d87a563fe47b43fcb8e7b7bfd011a1ac1e625ebfe9b5cc70cfda7b3feb7443f209d02b3fb0f59c9ec64c7dbfc76a64cb137fbe3fc5381e282159b33fe060da87699f16bfdbb2be92b1639a3fc6209ee8a8a359bfe51aa1f65f15783fc78a781c3ef0b23fdba292a63cfa103fecb94afb688c943fca99248f69e8963fdcb9b265b58f283fe7843bb68b87be3fd31c108a3e41a4bfaf9e98188d767e3fdf57358add1820bfe1342170e2359fbfeb0ff5e6a12c24bfea38afd6a059673fd96b816b476f4ebfcd5eef3f467f883fc09f78ffdeb96f3fc743ed75b60db9bfe1363cece4c6c33fe6c732e77052ef" + } + }, + { + "id": "certified-acos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffdc2a1ed76f657400334e7afc7ae463ff79306871934fc3ff943a498efca6b3ffceb7ca092e14b3feddddc9479606d3ffde1e9cdee834e400299b061ba22863ffdb7a505867eaf3ffbae7e2e40adf240016c58bf14b4543ffb8ccd9dfb47c23ffef52dca78d2c63ff8daa82cd429323ff0187c8e68517e3ff85a159b504c103ff7811950f6916c400033681307d76f4001650312a79e483fe9e78ac0f0f0cc3ffd1152fbbc4b163fed69ee8c1457c13ffd472197c58e163ff930bea2f4d8083ffceee4eacdec603ff91ff75763de3f3ff72e2da6dc056d3fe931936832a186400231162bfd22c73ff5edf113eb21d23ff4610df319313a3fffdab65eb33a0b" + } + }, + { + "id": "certified-atan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfdd863c3d652057bfe0816ba8cb539fbfe3ad7933637c1b3f9216bdb63a4110bfce42afb42d17223fd65cdb57e9ef5ebf79138d3bb8b8e8bfc5aba918ec311e3fcece03fb099fff3fc13edee8b3e80dbfde36fe8ca5ed47bfdc4106022d18523f9e20697262be1ebfb882ab90ebc5123fe1b23502609678bfd31be3f9deb599bfd20fed9f747fac3fdc8ffeba95b8213fe2df04b3457a57bfa0d232e7ce3d46bfcaebc219a9eb473fb989ab8f0c605cbfe28c9f0564930f3fd0fd3c916d79fdbfdad8c22ff506f13fceb1d7cdb7210bbfe4b91727e8fbd3bfe2359994863420bfbbdb0c5729803d3fc5b1180a2e0aed3fdcc20b75dc7b2a3fa1c1ec12adafeb" + } + }, + { + "id": "certified-sinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fd19901c946010bbfd919a26f4012ee3fe77c4966e838843fe3f9cff6a25a60bfd314cc38e45b47bf90c4798ddc6765bfd298142c317d2f3fd3d73b21e26a153fb2f45db0a03850bfd9f881142814ffbfe8c4ffac1ae37f3fdd3bb9738bde0b3fd27e36469fd39dbfd83e54f77d29893fe04be86700029a3fda58c1bbe7c4dc3fe6adc8b89e45253fe12c5d9b5770703fdf8fc172e0343e3fe53ced0d965f543fe55a935b0f47783fc278ec018e051e3fda5c92e11835c93fe04ae809f93975bfe0571dbe680e94bfc8d98b2aa135e73f84b26827e2f72d3fe97f1e5ccfb8f8bfe922fb6a6ddc073fdbf43cabf9f6c4bfc23a1d66e57d683fa16f93a5107320" + } + }, + { + "id": "certified-cosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000104974ad3ff13210db66d4cc3ff06ff09a981f1a3ff26784b5e8fe073ff53c169b64a4f73ff0c994f9a236cb3ff015656ceb44683ff54d2939c6181c3ff4d6af82cb62c93ff0aa57053a2a1b3ff53844d9f98cc73ff0fc725b643e9c3ff03496a3af4d563ff00229b76fe61b3ff22d35b1a6f6b03ff1c2f9e05a83513ff2949f0aea731f3ff33e2373e7a4c53ff13d63c11ee4f83ff000156d64ce3c3ff49f55c513efd73ff09f068bb8c6323ff32382bde5abf53ff08ecf02bd06c23ff029ab606955a73ff2ac8e32a430fc3ff284e70a6af2213ff3c3f3000596813ff0011ab5d3c2a73ff0721c4fd1664b3ff490148a2bd9903ff0df56f3dabeaf" + } + }, + { + "id": "certified-tanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfbee46032fe52773fd74e1af233c3d1bfddf718f5219c6c3fd91ac90f1935d7bfb4d65829a35a5cbfda4b83e7bf89233fe4dab1b34790593fdd6f8b6afecede3fe38a0aa112cc3ebfe34fbc988d59b7bfac2787891f65103fdc4e696100d9e9bfc8c9abb31b8e29bfd9b3a232017aa93fd343fadd7cf6793fdee904385cc1f83fdd214b34b35e92bfe2997dec11b6bebfc2d4520eee200ebfd4c2299e6710753fd7b75691eb781e3fe4f4bbd4d87858bfe2e3e4afaaa2843f7dfe963ad125ac3fe294717f500b23bfd40a063a3c15ed3fc31bdf754639a53fe12f2428857e2fbfe14bb86690b6c23fd666074260facfbfda0c3675ec1e62bfd29c4deaf85f05" + } + }, + { + "id": "certified-asinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfbd5b8ff223eb51bfd337fdb364bdb13fdb4ef46374d476bfcada9ac78b85f33fe45a8b77c6151fbf785e4746f1bb75bfc63d341bc5c507bfe13c20959fd58c3fe366867168f59e3fe743c51d8a68ebbfe56c22cca534123fe0df9dd7cad652bfdba0741613dae23fc5dac93556d05abfe747a1942c59a5bfe25b465acc15d1bfd93601214bd4923fe12b26d8ad2d5abfe676c1277ceb793fdad985453f784e3fe0d4236e30ee3f3fe747f4579bc7233fdcf952239b20283fc2edb2836ea7a1bfe5bfd5bf1c797bbfe31455d60870e4bfe14f526aaa6c763fb2f2f9638a54793fb5d5fc414b90f33fc862a3bbc27b8e3fd09483edc9532a3fe14dd5a918344b" + } + }, + { + "id": "certified-acosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe108a6b75517844004aabab23c133c4002c031bb5493803fd5364e30c4c35040049ee43f4963ee40020f5eda9b274240038517047c220a3ffde5873a7993aa4000ad6a99cb3c463ffb11590dce29b24002e9043bdfb3b24002d88c6bae7ec64002eb0defe4cad940041926694d64a24002c5f9ccd5d9623ffd253684fa8ea040047097138710b73ff39e9ab8989c5e4006050c707031464004c3102021eaf34000c8ebdfb31f8b400336136f0692bf400114520e1ddbd73ff7016eb7ea07ab40060ab1dafff62f4005c5bb216411644003354e66d05029400176395344c472400235b13a1b81723ffc0f415cd6a1e440031ff067f01a2d3fec7d0363f3cdbf" + } + }, + { + "id": "certified-atanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe0350dcbbd2f4ebfcb488839fa5fcd3fdcf12f3c8b29d1bfe7188d3ed13b9d3fbfb6dedc329b99bfbdae05a0ad2154bfa3203b10965771bfe19fa143dfd2a43fcdbf2d1b3ffab8bfe4328c11bb09713fbd43f7412d7b503fe8f90785109f8abfe10a8144dc3b7ebfe0839e1feb9a1cbfae42b740dea087bf83af8e02375c7c3fb5468f370352b3bfe49b8f309239db3fca7acdaac03c87bfeea3a963619c1c3fe2f306f85c6d16bf7628e971fb015abfd8a5046350ec72bfc7a0fdedf51de8bfba7ff42c3345a8bfd3904555d14de23fef6ff9f2f06efa3fdaefe527d990b53fdf8f5ca686ebf03fe8fc384b032ca2bfed2b6521fe1badbfd45961e61e7795" + } + }, + { + "id": "certified-erf-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfa5ed3b201e964d3fd3c600207a6e53bfb01bc434178b12bf9e5a98c565d19d3fe56750da2c74efbfda1c4ecc20f047bfb4c8726d4f2cc0bfde9fbdaeb47109bfd6f4ad2f537bf8bfc2cbd367b177d23fcf910ebf59bb6f3fb715414a9f4a1e3fd304d30ecb2daabfe63817610e3e843fe51fbfba6dc870bfdfa72d1fd5adf23fe4fec48063f6f8bfb8d42ab7abc5173fce5917af6536643f36dface3fa49babfa4c550012a6e79bfe3ee6a7650803c3fa4cf2ac187fc91bfe13a9f513203733fe78b8ec7356ef63fbb7ed121aec54f3fe5e1c7dbe2b37dbfc1ffb0f461e3d43fe04d26493232983fd4b5585f4228eebfdbde5e6d66692fbfe012885513e3fd" + } + }, + { + "id": "certified-erfc-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffba9c30d961d143ff60c839f7dba803ff4f55d2271a8c63fd6365ee8699b2b3fd863728ba2d9a63fd7d26807cee88a3fd2e260396fc8a53ff3eabdc7e0d5023fdfffddd340f2b13fd762d8feda5a3d3fe895a539a274933fd110e7a988148d3ffb11b6d1a427ad3ffa7e6a80a800b93ff567a86641154a3ff34ff8c8381e323ff4af35c8d358a93ff6fcb92751b5f23ff93b1e0935214c3ff6b034359d41e73fde8a45f67859753ff83b8e393f4d0d3ff971758a42579b3ff5d33e2ff371883fe12ec95e7ead053fdb2eddb75393863ff915df9e12f1903fe5ec27c3a584bc3fd2f6c6ed730a2c3fe44656344073443ff995a6ac0af7873fe0c1432b1a2465" + } + }, + { + "id": "certified-sinpi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfeff938701472ae3fe2e2e9f3f11e833febe1753ef3d7c63fe03a112106abd73fe35e49907032113fd4f79031660e02bfeab501e15b4162bfee34937a9566f8bfeabbf9c1ce1a86bfe80c68fbe54d0cbfeffb3a434aff113fefba89814f470abfedcf1d965c96c43fe6d607c4623692bfed3732794cdb67bfedf475dbbfab04bfeffb3f02c7f0303fe0cbdf8d5c42343fea98a23b0bbfdcbfe6e58da49347d1bfee19c9716d4b51bfee64bc8317b3523fe828c2a37176a3bfeffee75d2280a0bfefc8fe21a32c0ebfed4642dc6f3bd2bfd06b077db262db3fe3fc1b486ebc2c3fefd61fbdc00fadbfec2e05885d6efcbfed77293142bf923fee928244579119" + } + }, + { + "id": "certified-cospi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fefa70dd5948ebc3fe3a726d3dadb773fe8ed4c466d9e163faab7dcaceb5a1abfd76625553b8d74bfd0ed208babf834bfd79923e3498e15bfc224c4bed2d2893fc9977f14c86b703fedd3c655ef24aa3fa7949b44f4ee403fefdf24f8a7c9163fc33e878c108d473feffe42e3ce3b133fe0a6c8644d71e6bfbe69c17675cb023fb173729518e024bfc10898c95080f53fd352dc6f3912d63fd21d64f21179973fb2d39f877b385bbf9abe29b571526bbfb7f6790e33f7efbfdd05c4d34fb088bfa2c57607c812d53fefa138219816be3fdbd8b289341e413fef795df9d9e15bbfe8d912ccb5c05c3fc5ac36e44951223fee107594b5bbc03fd79214bbbb7cf8" + } + }, + { + "id": "certified-exp2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffae27d2096a6c93fef2f5d3d84e50e3fec5b3f2abc28423fee55ca76dc7ef83ff5f730810357933ff2ceb6751304373ff1c7ae6c5a34753ff0adf86ea4dff03fee0f6ee35a65843ff572de41dd5c523fec3beb529576793feaa4c2f40916e43ff231500dbb6f1c3ffaa504de2f566d3ff8ba158b7431673fe50468d67b1ca73fe9cc78ae3248813fe5498288db1af93fe5c249656065473fe72d757018ae7e3fe34c9728061eb93ff356310bcb54173fe2b574d142d74c3ff7daba58c613b83ff626e7d0219cf23ff00ca9681e045d3fe6cd6abc99449e3ff317ffedc0a6533fe625acdbdc0d7e3feefb972e29ced83ff41175a55f7a053ff78e95d6383efd" + } + }, + { + "id": "certified-exp10-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff3ed1f5f4dcb654000c4578d6d9deb4007a2289bc9581840129305be3c9f2340045a4154e357753ffe700eb1a163a7401767f5072d30b63fe6825b80275034400280caddad77fe3ffb5010a95814e83fe247aaf8ca9af63fd74e818e87c07b400a953c0f62c8ba3fd0f756e2fa9a4a3fd0cabde6175a993fdd0b34681a9fc33fd0b888dd018ab63fe7e813ed3746243fc5c72a3dbef0513fca55b941f2418c3fe00a6c1a8b0c3740159f402cabd1f440020440dc2e472740088784ff604a243ff4d540f2c99e273fdea88bc1ed314c3fd307cd46ec42fb3fdb075167e5d09640012211d753de2f3ff673013b86d1f53fc45f625e5b008140150272c92030e1" + } + }, + { + "id": "certified-log2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff29fbe641751003fed26677e1788d6400768ef5fb9d1924005e23f7eb4f3c23ff529dce2a5888040017de724950e2d4003e126060acd8bbfc5b73520c88248c00005973fe9c87d3fd91c30622e357940017edb9f9071eabffe529e22de7b38bfd5f1ad00e5bad1400768a3637ef71c3feccf7712578b4d3ffad8b626cc0a0a3f8493c24f41c00dbfffd998cbb07a8f3fd4b24ae4dd514f3fff176ba7adbd4240050f5ff894cfc940041887f1b5d89140000db4d601cde64000f89aced6f8613ffc5223ceb75e5b4005f45d94a94d82400438fbe0eb1d943ff7a8f510410ed63ff4692f8b6b36693ffdbb19ed448bcf400048455e10834b400076d0bb25565e" + } + }, + { + "id": "certified-cbrt-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfeb7d4503c104c4bfe76ecea145b6e3bfed0a33ec8d12db3fe79648c8c63988bfe7a0f8e6dbcd30bfe9f08eb6e28a03bfe57d5d7229d0c5bfe7ed121102471f3fecc742474a903a3fe2d1251d243576bfe8a54b32dd7a4bbfe254ffd86be0003feb0114e424d8af3fe381fa79b64389bfeca1c25b815d8d3feb0cd9dd71c6fb3fe48331b0cdcb2ebfe9d45d093eca04bfed01734200afd6bfe55af26ae40d953fd8bc538c4d09d13fe7a732b0d5ec423fe76d424692b09ebfe3f908aac730a7bfe851337d5ca477bfe3ff9f08b435813fe2a1eb9186c5853fd00839adaeded9bfea9356644bc7643fe9622b703cb9e33fe886b4fe33bc57bfeb7eed7076d914" + } + }, + { + "id": "certified-lgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe054e856f6a1ba3fd6909cdeb44d1e400ead8575cb36553ff211f35814dc6f401bc283eb47440b400a04b8948099fd401b2451ab31bf143ff4db50ac67f7aa3ffe276976eca3013fe001a4439461664016a3c1e000b6f7bfb256c45c544278bfb7b7a4c19932d63ffa142d0efa57b9400c72f2c1ed33844012578ca4f6100d3ff7da23e77272403fcc822dfa34e40e400b750bf9bad006401c205c2cfbf1433ff1aadf17b1a02a4015bf4a64b48d81401a25726a7f1c64400d78e61b0b2b414011482dd4dc1a88bfbef0f9b7db1f2e40024a7cb89c5994400da5f6214f8f043fe5a9a9854c3a41400591b46550bf65400fc1bf9d0c22aa4009022b4742d636" + } + }, + { + "id": "certified-tgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40a9549578418af53ffa60646bb9cd5a3fef52b1140a24db406ca1f88eba91c140af6baa57ecec7f3fecc2d3b32d39893fef6af566571f5340043b55adfaa0503fed475aa31da4a6401ec999eda8ceea4007c4c24d359fd9400b158668d4a19840b1a22d45d2c8543fecca1a9148f09d40038848a92db9004005c66940e59a514005dadfd39a775d4071d3a71984e40a4004f74f5597200e40888855bff0c86b3fedfbe6d79bcdca4090be895f176d363ff05b8c6d34d065408944b05798e0d13ff464c73275c2a03feccdff408e4fec408aa0b6051b9a9440a8d542b7433ffd40b1f10459c8a9c4407615eb71c6674f404e9cf096fb10d44000b3b12b59aca5" + } + }, + { + "id": "certified-hypot-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 512, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "401ada0da261c1b03ffbcd4ee3604a18401e0bc024219ecc400b25b90b13db4d401f22153c4413a54015831fc7042b9b4002705eb6491582401545b1e7249dcc401e008b04a3cc73401df5dae63b9e213feb091416ce74644011bb1d12bff22440097781105d7a173fe2228c94a8b7d7401c763a3f983bb53fff5774891d31d340058a255e09c19140007ee90339c99d401a1ee2a0a93d41401ec222e7062d6d401cfe6fe9152a133fed2349edb2912c40033077a91205c8401582349ecf94cc401b82655f81cd49400f6dc9a8acfe97401b5339b0a4e9b54012a4eda263b2234018086fe6573aee401702d5263677f64008fca60be038a6401a5029fc336d5f" + } + }, + { + "id": "certified-atan2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 512, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fa23a742b2419873fe4aec07c56878fbfb434166022448fbfa021969df11fa73fbc0a906e8f6ae3bfbff3586267569c3fb50d75ddda36053fb5a39f6a35f3bb3f9bbcda6927a81f3fe76f0fd9d3e0c43fc30301ab089fb23fc4e45fc4e8032bbfdc12944b321bdcbfcb733f706a0521bfc3fad50f96cd95bfb123960ab21916bf886c855abb17cd3fbb4ceab4a4b3023f8e3f6e86b581a93fcd80a3565250843fbed1a3c2ce0a103fb0f3750253ba723f8c99e52b42c9bbbfbb8d4cb3c58e613f89162cd21b8046bfb1c90fe95ca7d2bf832d0b37d722a93fe0a71ffcdf5e2d3fb6dd179e38f44d3fa7512ceb2c295c3fba5276c1d4ed803fab2cd062677ebb" + } + }, + { + "id": "certified-logaddexp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 512, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff4379c961088c940173e485c6087c8401c4de3117064d3401ad5b80656be4540038f0ce893282b401382bbbc714c61401582ce924985a9401b0d88f4e61edc401d28d04de4e263400d1222a4bf6965401d169110496e1a400196971a6f2461401e78734004b7a0401afaeb4c6905cb4013d388cd078275401d736364b0b85640171ffd018c551c4001fcca12c7269540117fafdb2b9b2e401cd7c961d36d923ff7ab3b59aff84f400fcee405fd95264018ccd6a7b5c1384015d8441ea8f4c340126bbf874dcf3e402007f72ebc86cd401587aacd7c404d4015669a5892fcb9401277ec40202028401407314ea6b77d401b792a34ff6c9e4018a307a1c64193" + } + }, + { + "id": "certified-fma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 768, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bffca1afbbaf3c103ff1443b35c2d0f0bfd54d30950a55b0bfd467db77e5c782400ea8c8acf18b3f3fa40af6b6f27fd2400348864b022ecebfd9b117a5af01d1bfeff2839101abba3fd3c41ec32a52f6bf73eba3634c6fc4c000b6950de331183ff08a80a957d73a400830321ca04bb74000297e0879e46bbffedfceef3c90a93feaa088e5da9f58bfe724ad8460a5e4c004da25d493889fc0061ca5ff2379043fe1a4632aad72a040031d28de85a32a3ff56a5ebc31c8a3c0064b1c47b8c6f7bfd578d85aa27a9bc00c3c592d4c0ec03ffc7ebdf56a7bbbbffe9648f89d233dbfe7532fcec84d01bfe952a969fe4b77bfba4faaac44a21a4010c2470a1811d2" + } + } + ], + "python": [ + { + "id": "signature-sin-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f576aa43f68c7b7", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f576aa43f68c7b7", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f576aa43f68c7b7", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f0a5140bed51133", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f0a5140bed51133", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f0a5140bed51133", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc75923c00bd7b1", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc75923c00bd7b1", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc75923c00bd7b1", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f966cfe40681e7b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f966cfe40681e7b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f966cfe40681e7b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fc583ab4070c7d0", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fc583ab4070c7d0", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fc583ab4070c7d0", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f42f7d63f76ca83", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f42f7d63f76ca83", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f42f7d63f76ca83", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fb504f3", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fb504f3", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fb504f3", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fa14518", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fa14518", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fa14518", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f800000402df85440ec7326", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f800000402df85440ec7326", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f800000402df85440ec7326", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040800000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040800000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040800000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fdbf0a940cc7326", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fdbf0a940cc7326", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fdbf0a940cc7326", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f800000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f800000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f800000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003e9a209b", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003e9a209b", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003e9a209b", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f3172183f8c9f54", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f3172183f8c9f54", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f3172183f8c9f54", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004010000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fb504f3403504f3", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fb504f3403504f3", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fb504f3403504f3", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000013f80000040000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000013f80000040000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000013f80000040000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fa818f63fd8b90c402c5c86", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fa818f63fd8b90c402c5c86", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fa818f63fd8b90c402c5c86", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004010000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000004000000041000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000004000000041000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000004000000041000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004010000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f57bb3d3f57bb3d", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f57bb3d3f57bb3d", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f57bb3d3f57bb3d", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3e21130b3e21130b", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3e21130b3e21130b", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3e21130b3e21130b", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f800000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f800000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f800000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4120000041200000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4120000041200000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4120000041200000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4000000040000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-float32", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-float64", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-float32", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-float64", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-float32", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-float64", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f0599b3bf68c7b7bf576aa4bef57744800000000000000000000001008000003ef577443f576aa43f68c7b7bf0599b37fc000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-cos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f5a5f96bed511333f0a51403f60a9403f8000003f8000003f8000003f8000003f60a9403f0a5140bed511333f5a5f967fc000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-tan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f1c9eca400bd7b1bfc75923bf0bda7b800000000000000000000001008000003f0bda7b3fc75923c00bd7b1bf1c9eca7fc000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff800000c0681e7bbf966cfebf056680800000000000000000000001008000003f0566803f966cfe40681e7b7f8000007f8000007fc00000", + "classes": [ + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-cosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f8000004070c7d03fc583ab3f90560c3f8000003f8000003f8000003f8000003f90560c3fc583ab4070c7d07f8000007f8000007fc00000", + "classes": [ + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-tanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf76ca83bf42f7d6beec9a9f800000000000000000000001008000003eec9a9f3f42f7d63f76ca833f8000003f8000007fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sqrt-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc0000080000000000000001a3504f3200000003f3504f33f8000003fb504f35f7fffff7f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-cbrt-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000d4cb2ff5bfa14518bf800000bf4b2ff5800000000000000026a145182a8000003f4b2ff53f8000003fa1451854cb2ff57f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-exp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003e0a95553ebc5ab23f1b45983f8000003f8000003f8000003f8000003fd3094c402df85440ec73267f8000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-exp2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003e8000003f0000003f3504f33f8000003f8000003f8000003f8000003fb504f340000000408000007f8000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-expm1-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf5d5aabbf21d2a7bec974d0800000000000000000000001008000003f2612993fdbf0a940cc73267f8000007f8000007fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c2ce8ed0c2aeac50bf317218000000003f31721842b172187f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c3150000c2fc0000bf800000000000003f800000430000007f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log10-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c23369f4c217b818be9a209b000000003e9a209b421a209b7f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log1p-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000ff800000bf317218800000000000000000000001008000003ecf991f3f3172183f8c9f5442b172187f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "negative_inf", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-ceil-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000003f8000003f8000003f8000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-floor-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf80000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-trunc-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-rint-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-round-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sign-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf800000bf800000bf80000000000000000000003f8000003f8000003f8000003f8000003f8000003f8000003f8000007fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-square-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f800000408000003f8000003e800000000000000000000000000000000000003e8000003f800000408000007f8000007f8000007fc00000", + "classes": [ + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-conj-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf000000800000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-real-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf000000800000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-imag-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-isfinite-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000101010101010101010101010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-isinf-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010000000000000000000000000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-isnan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-signbit-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010101010101000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fabs-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f8000003f000000000000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-absolute-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f8000003f000000000000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-abs-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f8000003f000000000000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-ln-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c2ce8ed0c2aeac50bf317218000000003f31721842b172187f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-acos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc0000040490fda40060a923fc90fdb3fc90fdb3fc90fdb3fc90fdb3f860a92000000007fc000007fc000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-asin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000bfc90fdabf060a92800000000000000000000001008000003f060a923fc90fda7fc000007fc000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-atan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bfc90fdabfc90fdabf8db70dbf490fdbbeed6338800000000000000000000001008000003eed63383f490fdb3f8db70d3fc90fda3fc90fda7fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-acosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc00000000000003fa8921442b2d4fc7f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-asinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000c2b2d4fcbfb8c90cbf61a1b3bef66165800000000000000000000001008000003ef661653f61a1b33fb8c90c42b2d4fc7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-atanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000ff800000bf0c9f54800000000000000000000001008000003f0c9f547f8000007fc000007fc000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "negative_inf", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "positive_inf", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arccos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc0000040490fda40060a923fc90fdb3fc90fdb3fc90fdb3fc90fdb3f860a92000000007fc000007fc000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arcsin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000bfc90fdabf060a92800000000000000000000001008000003f060a923fc90fda7fc000007fc000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arctan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bfc90fdabfc90fdabf8db70dbf490fdbbeed6338800000000000000000000001008000003eed63383f490fdb3f8db70d3fc90fda3fc90fda7fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arccosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc00000000000003fa8921442b2d4fc7f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arcsinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000c2b2d4fcbfb8c90cbf61a1b3bef66165800000000000000000000001008000003ef661653f61a1b33fb8c90c42b2d4fc7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arctanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000ff800000bf0c9f54800000000000000000000001008000003f0c9f547f8000007fc000007fc000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "negative_inf", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "positive_inf", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-minimum-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000ff7fffffc0000000bf800000bf000000800000008000000000000001000000013f000000bf80000040000000ff7fffff7f8000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "subnormal", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-maximum-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000000000000000000000400000008000000000000000000000000080000000800000400000003f8000007f8000007f7fffff7f8000007fc00000", + "classes": [ + "nan", + "positive_zero", + "positive_zero", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fmin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf000000800000008000000000000001000000013f000000bf80000040000000ff7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "subnormal", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fmax-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff8000000000000000000000400000008000000000000000000000000080000000800000400000003f8000007f8000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "positive_zero", + "positive_zero", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-hypot-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff40000000400f1bbd3f000000000000000000000000800000008000004003f07b3fb504f37f8000007f8000007f8000007fc00000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-copysign-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f800000bf000000000000008000000000000001008000003f000000bf80000040000000ff7fffff7f8000007fc00000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "negative_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-nextafter-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000ff7ffffebfffffffbf7fffffbeffffff000000008000000000000002007fffff3f0000013f7fffff400000017f7ffffe7f8000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "negative_zero", + "subnormal", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-logaddexp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003e01f96b40031c0e3ef2ba383f3172183f3172183f3172183f317218400ce3f53f903f2d7f8000007f7fffff7f8000007fc00000", + "classes": [ + "nan", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fmod-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000bf8000007fc000007fc000007fc0000000000001000000003f0000000000000040000000000000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "nan", + "nan", + "nan", + "subnormal", + "positive_zero", + "finite", + "positive_zero", + "finite", + "positive_zero", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-remainder-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000003f8000007fc000007fc000007fc0000000000001000000003f0000008000000040000000800000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "nan", + "nan", + "nan", + "subnormal", + "positive_zero", + "finite", + "negative_zero", + "finite", + "negative_zero", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-power-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003e8000003f8000007f800000000000007f8000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-ldexp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff800000bf800000bf800000bf800000800000000000000000000000004000003f8000007f8000007f8000007f8000007f8000007fc00000", + "classes": [ + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "positive_inf", + "positive_inf", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-atan2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000bfc90fdbbfc90fdbbeed6338bfc90fdb8000000040490fda340000003fc90fda3e7adbb04016cbe4000000004016cbe43f490fdb7fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arctan2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000bfc90fdbbfc90fdbbeed6338bfc90fdb8000000040490fda340000003fc90fda3e7adbb04016cbe4000000004016cbe43f490fdb7fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-pow-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003e8000003f8000007f800000000000007f8000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "ties-rint-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c0800000c0000000c00000008000000000000000400000004000000040800000", + "classes": [ + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "ties-round-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c0800000c0000000c00000008000000000000000400000004000000040800000", + "classes": [ + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-erf-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3e8d7aa73f053f7b3f57bb3d3f7ecd71", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-erf-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf7ecd71bf57bb3dbf053f7b80000000000000000000000100906ebb3f053f7b3f57bb3d3f7ecd713f8000003f8000007fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-erfc-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3f3942ac3ef5810a3e21130b3b9947af", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-erfc-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "40000000400000003fff66b83febdd9f3fc29fbe3f8000003f8000003f8000003f8000003ef5810a3e21130b3b9947af00000000000000007fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-lgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fa4ddec3f1286820000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-lgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f8000007f8000007f8000003fa1fc4d7f8000007f80000042ce8ed042aeac503f12868200000000000000007f8000007f8000007fc00000", + "classes": [ + "positive_inf", + "positive_inf", + "positive_inf", + "positive_inf", + "finite", + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-tgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "406809fe3fe2dfc53f8000003f800000", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-tgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc00000c062dfc5ff8000007f8000007f8000007e8000003fe2dfc53f8000003f8000007f8000007f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "finite", + "negative_inf", + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exp10-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe39ea9404a62c24120000042c80000", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-exp10-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003c23d70a3dcccccd3ea1e89b3f8000003f8000003f8000003f800000404a62c24120000042c800007f8000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-sinpi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3f3504f33f8000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-sinpi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000800000008000000080000000bf80000080000000000000000000000301490fdb3f8000000000000000000000000000007fc000007fc00000", + "classes": [ + "nan", + "negative_zero", + "negative_zero", + "negative_zero", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "positive_zero", + "positive_zero", + "positive_zero", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-cospi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3f3504f300000000bf8000003f800000", + "classes": [ + "finite", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-cospi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f8000003f800000bf800000000000003f8000003f8000003f8000003f80000000000000bf8000003f8000003f8000007fc000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-fdim-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-fdim-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc0000000000000000000000000000000000000000000000000000000000000007fffff0000000040000000000000007f800000000000007fc00000", + "classes": [ + "nan", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "subnormal", + "positive_zero", + "finite", + "positive_zero", + "positive_inf", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-fma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "bf400000bf000000000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-fma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000000000000000000000c000000000000000000000000000000000000000000000003f800000bf8000007f800000ff8000007f8000007fc00000", + "classes": [ + "nan", + "positive_zero", + "positive_zero", + "finite", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "positive_inf", + "negative_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-fac-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000060000000000000018" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-ncr-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-npr-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-e-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b1457694005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-pi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bf7452fc98b34e97bfed18f6ead1b446bfeaed548f090ceebfdeaee8744b05f080000000000000000000000000000000000000000000000100100000000000003fdeaee8744b05f03feaed548f090cee3fed18f6ead1b4463f7452fc98b34e977ff80000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-cos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bfefffe62ecfab75bfdaa226575372053fe14a280fb5068c3fec1528065b7d503ff00000000000003ff00000000000003ff00000000000003ff00000000000003fec1528065b7d503fe14a280fb5068cbfdaa22657537205bfefffe62ecfab757ff80000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-tan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003f74530cfe72948340017af62e0950f8bff8eb245cbee3a5bfe17b4f5bf3474a80000000000000000000000000000000000000000000000100100000000000003fe17b4f5bf3474a3ff8eb245cbee3a5c0017af62e0950f8bf74530cfe7294837ff80000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000fff0000000000000c00d03cf63b6e19fbff2cd9fc44eb982bfe0acd00fe63b9780000000000000000000000000000000000000000000000100100000000000003fe0acd00fe63b973ff2cd9fc44eb982400d03cf63b6e19f7ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-cosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007ff0000000000000400e18fa0df2d9bc3ff8b07551d9f5503ff20ac1862ae8d03ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff20ac1862ae8d03ff8b07551d9f550400e18fa0df2d9bc7ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-tanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bfeed9505e1bc3d4bfe85efab514f394bfdd9353d7568af380000000000000000000000000000000000000000000000100100000000000003fdd9353d7568af33fe85efab514f3943feed9505e1bc3d43ff00000000000003ff00000000000007ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sqrt-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000800000000000000000000000000000001e6000000000000020000000000000003fe6a09e667f3bcd3ff00000000000003ff6a09e667f3bcd5fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-cbrt-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000d54428a2f98d728bbff428a2f98d728bbff0000000000000bfe965fea53d6e3d8000000000000000000000000000000029900000000000002aa428a2f98d728b3fe965fea53d6e3d3ff00000000000003ff428a2f98d728b554428a2f98d728b7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-exp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003fc152aaa3bf81cc3fd78b56362cef383fe368b2fc6f960a3ff00000000000003ff00000000000003ff00000000000003ff00000000000003ffa61298e1e069c4005bf0a8b145769401d8e64b8d4ddae7ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-exp2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003fd00000000000003fe00000000000003fe6a09e667f3bcd3ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff6a09e667f3bcd400000000000000040100000000000007ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-expm1-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bfebab5557101f8dbfe43a54e4e98864bfd92e9a0720d3ec80000000000000000000000000000000000000000000000100100000000000003fe4c2531c3c0d383ffb7e151628aed340198e64b8d4ddae7ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c0874385446d71c3c086232bdd7abcd2bfe62e42fefa39ef00000000000000003fe62e42fefa39ef40862e42fefa39ef7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c090c80000000000c08ff00000000000bff000000000000000000000000000003ff000000000000040900000000000007ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log10-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c07434e6420f4374c0733a7146f72a42bfd34413509f79ff00000000000000003fd34413509f79ff40734413509f79ff7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log1p-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000fff0000000000000bfe62e42fefa39ef80000000000000000000000000000000000000000000000100100000000000003fd9f323ecbf984c3fe62e42fefa39ef3ff193ea7aad030b40862e42fefa39ef7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "negative_inf", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-ceil-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000003ff00000000000003ff00000000000003ff00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-floor-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bff0000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-trunc-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-rint-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-round-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sign-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bff0000000000000bff0000000000000bff0000000000000000000000000000000000000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000007ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-square-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007ff000000000000040100000000000003ff00000000000003fd000000000000000000000000000000000000000000000000000000000000000000000000000003fd00000000000003ff000000000000040100000000000007ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-conj-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-real-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-imag-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-isfinite-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000101010101010101010101010000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-isinf-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010000000000000000000000000100" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-isnan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-signbit-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010101010101000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fabs-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff00000000000003fe000000000000000000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-absolute-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff00000000000003fe000000000000000000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-abs-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff00000000000003fe000000000000000000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-ln-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c0874385446d71c3c086232bdd7abcd2bfe62e42fefa39ef00000000000000003fe62e42fefa39ef40862e42fefa39ef7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-acos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000400921fb54442d184000c152382d73663ff921fb54442d183ff921fb54442d183ff921fb54442d183ff921fb54442d183ff0c152382d736500000000000000007ff80000000000007ff80000000000007ff8000000000000fff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-asin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff8000000000000fff8000000000000fff8000000000000bff921fb54442d18bfe0c152382d736580000000000000000000000000000000000000000000000100100000000000003fe0c152382d73653ff921fb54442d187ff80000000000007ff80000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-atan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff921fb54442d18bff921fb54442d18bff1b6e192ebbe45bfe921fb54442d18bfddac670561bb5080000000000000000000000000000000000000000000000100100000000000003fddac670561bb503fe921fb54442d183ff1b6e192ebbe453ff921fb54442d183ff921fb54442d187ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-acosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff800000000000000000000000000003ff5124271980434408633ce8fb9f87d7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-asinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000c08633ce8fb9f87dbff719218313d087bfec34366179d427bfdecc2caec5160a80000000000000000000000000000000000000000000000100100000000000003fdecc2caec5160a3fec34366179d4273ff719218313d087408633ce8fb9f87d7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-atanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000fff0000000000000bfe193ea7aad030b80000000000000000000000000000000000000000000000100100000000000003fe193ea7aad030b7ff00000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "negative_inf", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "positive_inf", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arccos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000400921fb54442d184000c152382d73663ff921fb54442d183ff921fb54442d183ff921fb54442d183ff921fb54442d183ff0c152382d736500000000000000007ff80000000000007ff80000000000007ff8000000000000fff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arcsin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff8000000000000fff8000000000000fff8000000000000bff921fb54442d18bfe0c152382d736580000000000000000000000000000000000000000000000100100000000000003fe0c152382d73653ff921fb54442d187ff80000000000007ff80000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arctan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff921fb54442d18bff921fb54442d18bff1b6e192ebbe45bfe921fb54442d18bfddac670561bb5080000000000000000000000000000000000000000000000100100000000000003fddac670561bb503fe921fb54442d183ff1b6e192ebbe453ff921fb54442d183ff921fb54442d187ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arccosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff800000000000000000000000000003ff5124271980434408633ce8fb9f87d7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arcsinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000c08633ce8fb9f87dbff719218313d087bfec34366179d427bfdecc2caec5160a80000000000000000000000000000000000000000000000100100000000000003fdecc2caec5160a3fec34366179d4273ff719218313d087408633ce8fb9f87d7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arctanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000fff0000000000000bfe193ea7aad030b80000000000000000000000000000000000000000000000100100000000000003fe193ea7aad030b7ff00000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "negative_inf", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "positive_inf", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-minimum-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000008000000000000000000000000000000100000000000000013fe0000000000000bff00000000000004000000000000000ffefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "subnormal", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-maximum-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000000000000000000000000000000000000040000000000000008000000000000000000000000000000000000000000000000010000000000000001000000000000040000000000000003ff00000000000007ff00000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "positive_zero", + "positive_zero", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fmin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000008000000000000000000000000000000100000000000000013fe0000000000000bff00000000000004000000000000000ffefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "subnormal", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fmax-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff00000000000000000000000000000000000000000000040000000000000008000000000000000000000000000000000000000000000000010000000000000001000000000000040000000000000003ff00000000000007ff00000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "positive_zero", + "positive_zero", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-hypot-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000004001e3779b97f4a83fe0000000000000000000000000000000000000000000000010000000000000001000000000000040007e0f66afed073ff6a09e667f3bcd7ff00000000000007ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-copysign-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff0000000000000bfe000000000000000000000000000008000000000000000000000000000000100100000000000003fe0000000000000bff00000000000004000000000000000ffefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "negative_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-nextafter-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000ffeffffffffffffebfffffffffffffffbfefffffffffffffbfdfffffffffffff000000000000000080000000000000000000000000000002000fffffffffffff3fe00000000000013fefffffffffffff40000000000000017feffffffffffffe7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "negative_zero", + "subnormal", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-logaddexp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003fc03f2d54301d4940006381c3f0115c3fde5746fdb5c0643fe62e42fefa39ef3fe62e42fefa39ef3fe62e42fefa39ef3fe62e42fefa39ef40019c7e908f54213ff207e5aa8603a97ff00000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fmod-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000bff00000000000007ff80000000000007ff80000000000007ff8000000000000000000000000000100000000000000003fe00000000000000000000000000000400000000000000000000000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "nan", + "nan", + "nan", + "subnormal", + "positive_zero", + "finite", + "positive_zero", + "finite", + "positive_zero", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-remainder-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000003ff00000000000007ff80000000000007ff80000000000007ff8000000000000000000000000000100000000000000003fe00000000000008000000000000000400000000000000080000000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "nan", + "nan", + "nan", + "subnormal", + "positive_zero", + "finite", + "negative_zero", + "finite", + "negative_zero", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-power-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003fd00000000000003ff00000000000007ff000000000000000000000000000007ff00000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-ldexp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000fff0000000000000bff0000000000000bff0000000000000bff000000000000080000000000000000000000000000000000000000000000000080000000000003ff00000000000007ff00000000000007ff00000000000007ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "positive_inf", + "positive_inf", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-atan2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bff921fb54442d18bff921fb54442d18bfddac670561bb4fbff921fb54442d188000000000000000400921fb54442d183cb00000000000003ff921fb54442d173fcf5b75f92c80dd4002d97c7f3321d200000000000000004002d97c7f3321d23fe921fb54442d187ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arctan2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bff921fb54442d18bff921fb54442d18bfddac670561bb4fbff921fb54442d188000000000000000400921fb54442d183cb00000000000003ff921fb54442d173fcf5b75f92c80dd4002d97c7f3321d200000000000000004002d97c7f3321d23fe921fb54442d187ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-pow-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003fd00000000000003ff00000000000007ff000000000000000000000000000007ff00000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "ties-rint-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c010000000000000c000000000000000c00000000000000080000000000000000000000000000000400000000000000040000000000000004010000000000000", + "classes": [ + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "ties-round-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c010000000000000c000000000000000c00000000000000080000000000000000000000000000000400000000000000040000000000000004010000000000000", + "classes": [ + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-erf-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fd1af54e232d6083fe0a7ef5c18edd23feaf767a741088a3fefd9ae142795e3", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-erf-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bfefd9ae142795e3bfeaf767a741088abfe0a7ef5c18edd280000000000000000000000000000000000000000000000100120dd750429b6d3fe0a7ef5c18edd23feaf767a741088a3fefd9ae142795e33ff00000000000003ff00000000000007ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-erfc-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe728558ee694fc3fdeb02147ce245c3fc4226162fbddd63f7328f5ec350e65", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-erfc-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "400000000000000040000000000000003fffecd70a13caf23ffd7bb3d3a084453ff853f7ae0c76e93ff00000000000003ff00000000000003ff00000000000003ff00000000000003fdeb02147ce245c3fc4226162fbddd63f7328f5ec350e65000000000000000000000000000000007ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-lgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3ff49bbd81c16efb3fe250d048e7a1bc00000000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-lgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007ff00000000000007ff00000000000007ff00000000000003ff43f89a3f0edd67ff00000000000007ff000000000000040874385446d71c34086232bdd7abcd23fe250d048e7a1bc000000000000000000000000000000007ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "positive_inf", + "positive_inf", + "positive_inf", + "finite", + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-tgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "400d013fc47eeeea3ffc5bf891b4ef6b3ff00000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-tgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff8000000000000c00c5bf891b4ef6afff00000000000007ff00000000000007ff00000000000007fd00000000000003ffc5bf891b4ef6b3ff00000000000003ff00000000000007ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "finite", + "negative_inf", + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exp10-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3ffc73d51c54470e40094c583ada5b5340240000000000004059000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-exp10-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003f847ae147ae147b3fb999999999999a3fd43d136248490f3ff00000000000003ff00000000000003ff00000000000003ff000000000000040094c583ada5b53402400000000000040590000000000007ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-sinpi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe6a09e667f3bcc3ff000000000000000000000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-sinpi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000800000000000000080000000000000008000000000000000bff0000000000000800000000000000000000000000000000000000000000003002921fb54442d183ff00000000000000000000000000000000000000000000000000000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "negative_zero", + "negative_zero", + "negative_zero", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "positive_zero", + "positive_zero", + "positive_zero", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-cospi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe6a09e667f3bcd0000000000000000bff00000000000003ff0000000000000", + "classes": [ + "finite", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-cospi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003ff00000000000003ff0000000000000bff000000000000000000000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000000000000000000000bff00000000000003ff00000000000003ff00000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-fdim-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-fdim-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000fffffffffffff0000000000000000400000000000000000000000000000007ff000000000000000000000000000007ff8000000000000", + "classes": [ + "nan", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "subnormal", + "positive_zero", + "finite", + "positive_zero", + "positive_inf", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-fma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "bfe8000000000000bfe000000000000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-fma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ff0000000000000bff00000000000007ff0000000000000fff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "nan", + "positive_zero", + "positive_zero", + "finite", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "positive_inf", + "negative_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-fac-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000060000000000000018" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-ncr-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-npr-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-e-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b1457694005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-pi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-domain-fac", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-float-reject-fac", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-domain-ncr", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-float-reject-ncr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-domain-npr", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-float-reject-npr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "where-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000080000000", + "classes": [ + "finite", + "finite", + "negative_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "where-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000008000000000000000", + "classes": [ + "finite", + "finite", + "negative_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "status-invalid", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000", + "classes": [ + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "status-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000", + "classes": [ + "negative_inf" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "status-overflow", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "7ff0000000000000", + "classes": [ + "positive_inf" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "status-underflow", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "status-clear", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "4000000000000000", + "classes": [ + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "status-lazy-where", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000004000000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-sin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-cos", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-tan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-sinh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-cosh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-tanh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-sqrt", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-cbrt", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-exp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-exp2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-expm1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-log", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-log2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-log10", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-log1p", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-ceil", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-floor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-trunc", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-rint", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-round", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-sign", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-square", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-conj", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-real", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-imag", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-isfinite", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-isinf", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-isnan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-signbit", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-fabs", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-absolute", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-abs", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-ln", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-acos", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-asin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-atan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-acosh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-asinh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-atanh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-arccos", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-arcsin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-arctan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-arccosh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-arcsinh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-arctanh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-minimum", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-maximum", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-fmin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-fmax", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-hypot", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-copysign", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-nextafter", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-logaddexp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-fmod", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-remainder", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-power", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-ldexp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-atan2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-arctan2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-pow", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-erf", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-erfc", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-lgamma", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-tgamma", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-exp10", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-sinpi", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-cospi", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-fdim", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-fma", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-fac", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-ncr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-npr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-e", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-pi", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-where", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "spelling-reject-float-power", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "spelling-reject-logaddexp2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "spelling-reject-heaviside", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "spelling-reject-spacing", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "spelling-reject-frexp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "spelling-reject-modf", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sqrt-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40105d8e3ff2010b3ecf06eb402b212f3ff09d163fe26b5240052a793fc89d8940094087402a03843fd056e640081a6f4011d2013f527df7402d1e95401dc1023ee6007b3f77ac403f56292b3fcc07a13fd0fb0340209ffd3f96db6140208f4d4006bada4007ec5f3faeabf0403007b5401c56354000d47540022247401acaf5", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-exp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f813d1b3f8724c5400a58663efbef813f021fd23f8bff413fd7959b3fd3a1073f31e89b3f949bd43ffad1273fbdc30c3f990fb83fb445c63fdbfc353f0b765e3fe8b0683ff53f703fdd4cbf3f4684193f9764853f07d5803f628dd73f9e3c783f629c443fc238073fbeffb93f29bcba3f80e7873f0ca8073fc19f063fb29f08", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-expm1-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "be99f8f43f4b334ebf0b574c3eaf7a75bf0b8cf6befbbd9cbf05a2c5be9022ae3eee010bbeff6c3a3f6d3fba3f903ffd3e82c68bbe8d6c773f8d6a963f36f312bef50acdbe3b52e03f176d523f76d5a23f15f6843e0e132dbe95f42b3f512cdd3ed1ae9bbecaecf13f8c7b4abe2378ca3e5780633e1b9c663e32de9e3f16c859", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fafe8f73ff051663fe8309c3f9c33913fa598c43f6f69533fd0c91e3fefd8e83fcca67c3f95f94f3f0cd4e64001742f3e0a2e773f40a9e5be92c2603fd1d8c73febe7663f5806323fad18363f94eaf23fe3f8513fcf36633febb32f3ff32fa43f9828023fc67ff13ff003183ea6670f3fdf163e3fe3b66f3ebe29e2bfa442fa", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log10-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f08c0d63f4acee6bf1f75c83f46cce8bd2c6ac93f38283c3f2ab4dc3f21116f3f0ab6c43f44775d3f1a04403f3769133f567652bf1f26aa3e4fa7463deb93b73f6097b53ea1f5243e28fe833f3cbbee3e66b61c3f3ae929bf09f95f3ed428cb3f5f70d73f65912a3f47a33d3cc44de43f33cc2e3f57eb023f50d38b3f3e5993", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log1p-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bec18fd5be23a284bf8db1b33eac6b8c3eace35f3ef04f89bc50e3e9bee7d0843e48c7d73f0b614ebfc75e6abf429ca43de9c11a3d617799bd7b0ade3dd410a9bfb47cf3be9bb5923ea9cd773f04c2e6bf280d26bf57e827be1c0b913ecfe6abbe7170e63d5195f43e3231d1be2c1ff6bd92560ebfb68558bd5aed57bed5785b", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e90b434bd93cbad3e745e673a8e77e3bea240cc3effe444bee149fbbeb64be53c8a0b30bf0abcbabe6fe597bf1b47bb3ed2427dbf33ad98bf27578fbec8fcdfbb8b6562bf189be33ea17b4e3e5652be3e8a85acbd45b842bf1e487b3ec9e6c6bda90f2fbf292d0c3eae305c3eb898643f051468bf04cf77bf14b4febf03c68b", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f7ffc033f549cb03f36b8743f4a6b463f78c57f3f7f3b753f758c0d3f6469513f7cb6903f76d5893f78af4f3f7ae0ab3f7a31a73f7ffa373f64356c3f7b94d63f775ff03f7d1cc63f6686d63f55e1c93f7ebde53f6963293f731fc63f5e5a1d3f62cd723f61fbb93f5e56973f7a4b6f3f5a452c3f7ef69a3f7eaa013f3b994c", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-tan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf30792c3f65c7803edf6621bf8355d03e9afa1dbf791bce3edc2a0a3e2f94c43d5873113e1f804abe5a0dc2bf3193dc3e98c6c2bf4ca6583f82324bbb8a28ef3f275a773f4326f13e31309e3f0c324bbf6de3d03f0ca5193ebb7082be805cea3e852f92bf1312e1bf7ad958bdc0b60cbe93b2f1bf4750b6bf468002bf465ec5", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-asin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf57cf763f16650f3e9c1ac03ed0a6d23e9b73f3bf54dda4be4407c9bd14b5d8be762717bedafdaabdd008d0bf1d0c2d3e164435be8fe9773dfc59ecbe1f07ce3f64240b3e95412fbf36d9df3f16a82a3f157edc3f2e35613e55b1163e6949163e9751483e6c99f73f0e7ef9be759bd8beba52e93e611600bef00540bf177f14", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-acos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fd864ad3f5e6b673fa71a313fd0fa073fcbc77b3f6e78143ff7690f3f5ad1683f9bc89c3f9d0b523fbe26424014a2a43f6f65e74005c02e3fab4fbb3fd4e6e63fa3d8ca3f414538401f2a223f3a9d423f4c17e33f70ef8b3f8d22be3fa64f993f9981b63fbd09303fd54980401afacd3fe8cbbe3f91903f3f5182923fb0a6f8", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-atan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf2c528c3e9d6ce63f02d22abe03a07c3f1783233ec846ba3f19d5fd3eca6df7be5fc6f63f110bdbbf229731bea656e83d8d290e3ee2c7e7bc47f180bedb39583f0d01e23ddd9ba6bf066206bf2980dcbe02e65abe82f820becd09d2be4e8b80beb3cad03e99a332bf12aba73eaf3775be5f93f83e2acf9dbe002c343ef5e556", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f5e67963ec641a43f36285bbefde3f43ee8406e3e74d40f3f0af65abf4f1bc73f526aa0be2e41183f624160becbfaaebe5159273f446ed33e77910a3f1601d13e50d35dbf2d092f3ef6de40be84aea03dd3a80a3f14dd47bf547d9c3e53e7f53db02e5f3e247052bf5c04bbbf197828bf08250fbf305c0bbf24ff733ee7c75c", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f850fee3f847be43f875e3e3f8159d33f97e6383fa6528c3f88ba3b3f825e883f9893bb3f807f8d3f84d87b3f815ec63fa726473f900dbc3f80ea4e3f8aea283f9004683f83ccb83f8499203f9ad3673f80f49d3f8066df3f9750c23f8505063fa6070c3f96ba803f9e098f3f81af843f8029073f8dbdf13f80f7953f80577a", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-tanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e61ef53beb515ee3e3e0d81bed252c53ef504753e0e8383bf0396abbf1668603eb280033f1406413f03d769bee9ae563ea7721b3e5a6419be54f5663d8c83573eddf2053f276c54beda11d3bf219dbb3dfd0be1be914fcc3ec970a3bef5845dbf2218f53eef8b633f18275bbd4593fbbe8110533ed690fcbf24e159bf019fef", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-asinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "be9b06b1bef70d09be968df83e9367ed3f212b50be8ed979b981e86ebe8b485cbedb1637becce82ebf0137bf3eb576133f1dfa6dbf06fd35be7ba7133ed7c179bdef7f113db56790be14b300bedea40ebe244b6bbed0b831be9620a03e8fa4dbbf17a1813f3866c4bf005be6bea358ecbeaa1f6dbe457a733ec121583e81dc52", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-acosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "401a177d4024e7354023e0cc40036ad03f982fe14008133a3ffcd4773ffe9df03fc93bca3f7b0d013fccdc4b3fc3048b3fd1d2453fa0bce53ed4bdb83fbded193fe6639740236d773fb4063e3fd8616d400ceae73fa7414e401a6a9c401577bd40279a9d3fcc276b3ff8706d3fafb6c040224e313ec2598c40231b8a400ad9a6", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-atanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e8632dbbe22c68d3ef507d3bf2b250d3ed9a0a73e6a4923bf7ac3c53e375387bd614dea3ebcdfe53e8d8f39bdbbd68dbee6c7793f39bf903f1f138d3d013735bd1c33e8beb4d316bf86c132bf822bf13e48a0343ee52d85bf2681923f5505b03f4738043edddf963e2ccd813f155747bf524b85bed4bec73f1c2adfbec9421d", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-erf-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf0481ee3f35d43d3db7b4353f08ffedbec9f49a3f0d8e8d3edb1f043f3516563de04e4dbf37abf23f3df04b3e1a4cc23ea96917bee4b4683babff19bf09b686be7d2dd6bec00a8ebee892063efb4f063f0e5e073f3b055ebec53f993e3f0f9b3f3149b63dd54fbabeeb0d3d3f276090be309378be6fe1933f1ae877bf243d28", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-erfc-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f3a00b83edbb9613fae6a543fbf4cd13f1426ef3f9dfc7e3f88e5b83f74b6583f60dc213f6380c43ea1734e3fd9323a3f6b053e3ead882c3f169dc63f21f8583f912fd03fbfeeae3fb5fe003fa61d9d3f1534933fdd6e283f8cd1ce3f955c323e914fa23fa74f383ee06dcb3f146ee03fb401503ef744c53f5b0c993fc28ab9", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sinpi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f44d2a2bf67b1083f29c6c9bf6282b8bf7dc236bf7ef96d3ed93ff1bf3792cdbee57bb4bf7ed6ea3e6985913f11af743f5379d2bf66ad293ec23b573f5751713f1ec5363f78c2cb3f754e1ebf586036bf12f3e23f451781bf7856fe3f35d6733f5434813f08f5dbbf55a835bf7dee8ebf273d463f7fc0643f42a7943f78ead0", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cospi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e9c8c0cbe4d19ae3f778d8c3f4d93833f6bc1f1be5ebe87be07aa643ec95cfbbe9d0ef23f65ec413f30f05e3f36e9e83eeb69293f7fb5553f719ebbbf065be1bde9b67fbeb5c0653e3c8bd7bf1492a4bec8c5b43ed65d683f5418e6be6b979d3f750f8bbedb1f90bf2503ce3f72f63f3ead62163e35305dbd74f210bf425070", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-exp2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f993ed43f1e63e93f21ce3c3fdc0c183f17c5033f5ff2333f9782de3fab9aef3fd878773f6b98893f7cc71d3f32587e3f581f0c3f5613a63f615cf03fa547363faf26f53fcbf4933f847a913fd919843faa474c3f1328413f9dea4f3f4bf0d83f870d1d3fbcc4713f6c28fd3faff87e3fb3e2133fba420c3f975eb33f9034b7", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-exp10-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e5cca2f3f1dc935406d14363f000b3b40c8fb9e3e2ead5c3e49fb6a3ea0f4113fa72d233e6369dc3e96418d3f1cd5733ff79dcd40a842b43f2196453fbc911440113d4a406fdfcf3e43aa193f4e57fe409516d53e89a906409953813f7b399f3f6cfe393e87b3793e2859da401d521c3ee799c23e3823e83ec17816407646a7", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40285017bf0d0acb4034f09d402369d73fe2ac103f06a682401d431a40067a4c4014d7e6beb430f7403177903fd607f340144756402f1afc40183fbb4023809e3fd0073e3f6061a23f047c54403cd7143f2042d33f2785033fec2170bec717773fdb10453ff69f8a3ff954fb403e39de3ff09122bf582e074024500abfd365d2", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cbrt-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf1a50aebf3f30bdbf3b696cbf4f80403f447bbebf661625be6f01043f2bb0203f4fa4393f680a1ebf482bc3bef443c5be864d4c3ecb2526bf62cbf8bf35de08bf1feda5bf536884bf222f8ebf51df5a3f6c3ba8bf6d0993bf2cf6643f4f32f0bf4ec8353f66610dbf286d53bf4f03df3f462ae13f6823f3bf046a873e9c06e5", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-lgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "405195ff404e573c3fa2166140b9658abc81d4684105e9414064196740768a713f80c67540c4b30c40eb493ebdebfc9340a07de940cacb443fcdeb503f9e1b9e3f63661240af7d69400dad203f96792abdf8cd21410259f940f5b4db4025b71bbded74833c27b0fc402ea56f40ee5eac3e25b85a3fd9038e3d820a313ff0ddc9", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-tgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "4481d56e41bb56283f67f9b243d99468411f928e4095a5bc408195c7412edc6344ec102c41ca2e2a426996ce3f7daec2421be1af42beb0da40841a8442c4c01f41d24f9b445fde7a44610723402d598242efcf234048675d4273b12d4312ea89458674664215f82140d1777a402af16a40385ffc437cdbc83f64bfaa3f69efb4", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-hypot-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40843bab40ca83cc407bc72d4076ada23e84650d40879d063f8ff1ec4091f9b640de2dfd40c58bde40b9130940a285f640dfe1c44082ea4b4083e1023feae4a840111eb04053289740e78e87404a6b12409f0bbf3fd3789740df201040a8426f4006f0904021a315400113f940e867c73f42ea393f5cf8da3fef896d407d0411", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-atan2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "be8590e4bded1ffd3daa93ea3d4be5ebbeb8aca8be693288bd8083003de40e013dbb097c3f1aea43bd0ea23fbdac6ca73dd733933d1be51ebb1f85d9bd56e947bd47a1613e2924743dab71a1bcabbbc8bd3d016e3dced4373ee94bf2bbfba658bca54aec3ce1a724bf1ab09e3a7cd97cbe67d01f3d342a36bd1b663fbdb66c4d", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-logaddexp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40f8c9e63fb8ae2e40456765407b59fc40eb52c640e3b3e940c261f940f0da7840055d98409eccc04095d07040da7a4b40f5ca44406fd07341004f1140d7bebc40f3554740e8dafe4055e03640f594cb40f35f944048ee1a40afebd740e5fbc240d9db2a4106f1194053c3b640d01e174064afd140ba4a8b3f62e44f40f6fdaa", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-fma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "400e6b73c07aeaeebe95c3ff3fa60e26c06006503fcd0f8fbf6b0a0d3f9db340409b1b6ebfb86cecc0920af5c0b2bb44c0110ababec3a464403c5ee8bfaaf170c0305e573f000441bf509ca0c098de0a401c05004004ac56bf96e38ebea14e4ac09987e1beb4c83bbecf9c83bf935e9cbe72b635bfeb93913fb0b9d23f72011c", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sqrt-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40003be8662a5fb43ff17d28dc1939d73fe623ff8594f5134005f50bdba3cfa540022734b7acbe413fe5dab668b3126a3ff8830c80c000c040047d7528c7308c4000a5a085a5fb6f4003aa06c7aa116b3ffb8df4e0636edf400461bc406b5b363ff433e1a470ddd33fffd91365146a303feef157252cefb23ff69d2c9bd4e8b04003d54ef6f2cc214002b56471febdfa3ff8c777799bd1bd3ffa5d1df156e0c74003b8210119791d3ff75d4ca9afac9b400553f493d117e84001a2b63ee8e1304002f7e74f1b86423ff94ecafd04225b40020f39e7bb6d354003e2f7546ef0b93fe795aa4a607a703ff75fec854d201840063eb18a3c0e433ff5d9e8925f837c", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-exp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe8cf9f96d70f593fde973644f9fe663fe22892e4bd6fc83fde2afb2405f5ca3ff4f3ad24acf3543ff276fc441d4c7e3ff85b2c3a62884a3feb1d51a7be45183fe0580d424f06d03fe2856852b6b2cd3ffc56e39ce7883b3ff4e7d08112b6323fe180894c24ec303fe24ba3156c25403fea5c9f5478a61c3ff3fb0072939be53ffbac769a77e3c63fdd6bdb37e5f93b3fe21f21ef5347f13fe8316adbad314a3fe6287f6861891240013928063665063ffc58e0be6f4dcf3ff9d3d50b310ddc3ff1aac8b1af41583fdf70d2db4edc263ffbc07c126f951e400107d1869c407f3ff483a8ce871ec53fe14ee49e5fc72e3ff2e0c8c04ac3cc3ff56f7c46e28ebc", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-expm1-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe9994f99c2353d3fe0f0dd923a55c23ff0ff0acbbbdde43fd6ce5ec8f5a963bfd3ee3010b035433fe4d1b06cf9a6b9bfd7a42be64b6b2fbfc35e481f8c8c983fdf05ecaf28cd293fc9c3121379f2df3ff199b6b52859223fc1007234619bda3fdc8d4918a2b58b3ff12e4c166a19063fc9551cc084b1153fe794bae832df62bfd1f36036d8c761bfe16d612e0b56eebfb59b8e79fa3f573fd60de7116536a8bfe0276d018418023fc3007f6f9e1eb6bfc53c8b9bcb70bbbfce7a377a90754c3fd9db676c58b1fcbfd5c651af351a4ebfde5c9d5569fe61bfdf5cd019caaa56bfdf6ebcefe3569c3fa00d1d7526dc44bfd1f9ab36007df8bf7a57d512bdefd5", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffbfdba27e447593ff3b55a0f5454153fff592f8c5ba6b53ffcf225e992e8273ffa320b51a1a8cd3ffa319b87b6396b40005046b8575b764000159cf0870b7dc0013c869a3ce87d3ff643b42dbf22d3400090ed49d4c7233ff208ea175be4e33fe6389c0dc8ccb9bfe5cefd96631f053ff9533cd948d2cf3ff3827c220bc4333fb3c2c074d326e93fd349eb0c10fc893ff53c0c5f54b4af3ffe1549a786d979bfe16a78239041763ffd3a0d5b12531c3ff4b556378365453ff97930157530a93ff7ee65ad2306eb3ff874f431d61d773ff22cd5bb5d03dd3ff15a62aa91d2d83ff537ecd46687053fddf8e68cd2f7a63feedc8fea7679ec3ff884ddcb1ba4a9", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log10-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe758a636fe51e73fe5002664c1db7f3fece4c1c8b1d4a33feade0934d8c1ed3fe41f1044d168553fd0aa1642ea02623fe0aa839c8cb9693fe6a48e374c63693fe4c5531621d8183fd4f853951fde483fe623f9b0290cfe3fd8a019b3d537083fb1a7987ccf6f9d3febe97e41dcbc8c3fe298b3bf9545643fe4960c8c2fc32c3fe82e1df671dfa93fe60d9f6a208e7d3fc61053c258b7f93fe68ddf0bfc706c3fd70e04133f25493fe31b1462690adc3fec139cbc73a2aa3fe9cd9f705cfa683fec1a84550ef3873fec4180205cb59c3fd9d8c6e2afdcb43fec455099710ba43fce6ce02ea308463fea8817fc28b2b5bfd3b93549806d513fdb2774a4544804", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log1p-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfc1e43d085cb220bff13126bea0a058bfaff5c51259f2493fddf06fbac80775bfe9fd5d586aa21fbfc4e81a78f39a3dbfedcdb22b08e4153fd47d4aed5dbf5a3f93f360310ae91e3fadf3db18443cc03fae723753b0ff01bfee8d2f0bdfe0c33fd71745a00d8fcfbfed4f9c20edf5403fc59e24761b9d73bfb444cefe38a0d9bff03696740d7437bff8c0d16edfdfb43fc5dbfcde040cb53fd43d31524b5f74bf742f939938c3c73fd39cf310c8f106bfbd8d5a8e30f6593fe1b8406a2e69413fbea632ede9ca833fe1f038a8ee9d81bfea7403198a5e67bfd9a31cb26494e23f92b7abb69900d0bfe710ab762b4596bff512711a21f5813fdf55b3093c2b57", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfd647eab328f2ecbfe6291ae1148e213fe1a935f0b136a13fd7395ed31883f2bfdd4c30aefa15f83fd18b3b83f4ee9abfe0ea4d243841083fc65359928d381c3fe0775a321b6625bfe16fabcb340447bfc9f585059082f5bfd48a739e28ad193fe67824a911a33abfe2f08f76520d683fd480b6f8de53d53fc50739e7392bcc3fe2187a52fd65e93fd8fc770f947e4c3fb83164779f5b273fdf9fa6fc91e5933fe1bae938ef4e31bfd709a0d77e44163fcbe6e3f98944333fe4e22af1f74dfbbfe361d961d2b456bfd2c5038afd99213f966d5f53d18531bfdad2d4a1ae6425bfda0b58126e6e823fd556e30c7a50b1bfe48c22be57217f3fc9654224c13bdd", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fec927e8d46bd4b3fe8cf43dedb55613fedcd55b454550b3fed448cabf4b6ca3feeb77e3de6f2f23fe946cad1c8d39b3fe99307eb9a2e593febc9455c4b8fd63fecc39afe638a0a3fee67362375dd503feb75d227f50f123fe89917254c41f53fefe6644a10bcd63fee1243c57839783fe668f376c1364a3fee1d1a98482dab3fee9fa15fb834293fefa3af114ce1153fe9b9c72c65eef33fea18fe77eec69c3fef24afa878db383feff53821de16ff3fe83fab5ac1eb383fecbd9be970c7fa3fee2a8f36ed48443feb8e6f2f4a57933fec9dcc5b9693533fe7edc621a534c13febe5867a0d93873feea1f95b38e9843fe9b8a67f0593403fec0670b4fa43b7", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-tan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fbc22a4754c7723bfbb2ff162f7e1ef3fe484c5c4e68cd73fea6066615a78bdbfd9e3fa24aa753c3fb6e718eba13806bfd585aba0dfae343fd13e1b2e534f55bfa0135db053c7023fe0a0d0009ed35fbfe065a708874beebfe9cba2fd5cdb093fe2bcaace7746703fefd6ff78539a75bfd6860f77880102bfe9d755ac77151dbfe14d5596872181bfc198e97bdb60a8bfb3609f435fbc943fb547c23964e4d53fe8e026bf1d6baabfb1eb131a7c1725bfd2568d655e7e673fed17dc7dcd2d003fd8d1e28a25cd9d3fa175cf4d0c4df23fc99e524e62d1b4bfe6be39de491c91bf9d1021a344d8263fe2a944f2b2666b3fa57208eca541be3fe4f5a32f3b728a", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-asin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfcdeb737886df7cbf9434bbf155299dbfe2fcea06d87a563fe47b43fcb8e7b7bfd011a1ac1e625ebfe9b5cc70cfda7b3feb7443f209d02b3fb0f59c9ec64c7dbfc76a64cb137fbe3fc5381e282159b33fe060da87699f16bfdbb2be92b1639a3fc6209ee8a8a359bfe51aa1f65f15783fc78a781c3ef0b23fdba292a63cfa103fecb94afb688c943fca99248f69e8963fdcb9b265b58f283fe7843bb68b87be3fd31c108a3e41a4bfaf9e98188d767e3fdf57358add1820bfe1342170e2359fbfeb0ff5e6a12c24bfea38afd6a059673fd96b816b476f4ebfcd5eef3f467f883fc09f78ffdeb96f3fc743ed75b60db9bfe1363cece4c6c33fe6c732e77052ef", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-acos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffdc2a1ed76f657400334e7afc7ae463ff79306871934fc3ff943a498efca6b3ffceb7ca092e14b3feddddc9479606d3ffde1e9cdee834e400299b061ba22863ffdb7a505867eaf3ffbae7e2e40adf240016c58bf14b4543ffb8ccd9dfb47c23ffef52dca78d2c63ff8daa82cd429323ff0187c8e68517e3ff85a159b504c103ff7811950f6916c400033681307d76f4001650312a79e483fe9e78ac0f0f0cc3ffd1152fbbc4b163fed69ee8c1457c13ffd472197c58e163ff930bea2f4d8083ffceee4eacdec603ff91ff75763de3f3ff72e2da6dc056d3fe931936832a186400231162bfd22c73ff5edf113eb21d23ff4610df319313a3fffdab65eb33a0b", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-atan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfdd863c3d652057bfe0816ba8cb539fbfe3ad7933637c1b3f9216bdb63a4110bfce42afb42d17223fd65cdb57e9ef5ebf79138d3bb8b8e8bfc5aba918ec311e3fcece03fb099fff3fc13edee8b3e80dbfde36fe8ca5ed47bfdc4106022d18523f9e20697262be1ebfb882ab90ebc5123fe1b23502609678bfd31be3f9deb599bfd20fed9f747fac3fdc8ffeba95b8213fe2df04b3457a57bfa0d232e7ce3d46bfcaebc219a9eb473fb989ab8f0c605cbfe28c9f0564930f3fd0fd3c916d79fdbfdad8c22ff506f13fceb1d7cdb7210bbfe4b91727e8fbd3bfe2359994863420bfbbdb0c5729803d3fc5b1180a2e0aed3fdcc20b75dc7b2a3fa1c1ec12adafeb", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fd19901c946010bbfd919a26f4012ee3fe77c4966e838843fe3f9cff6a25a60bfd314cc38e45b47bf90c4798ddc6765bfd298142c317d2f3fd3d73b21e26a153fb2f45db0a03850bfd9f881142814ffbfe8c4ffac1ae37f3fdd3bb9738bde0b3fd27e36469fd39dbfd83e54f77d29893fe04be86700029a3fda58c1bbe7c4dc3fe6adc8b89e45253fe12c5d9b5770703fdf8fc172e0343e3fe53ced0d965f543fe55a935b0f47783fc278ec018e051e3fda5c92e11835c93fe04ae809f93975bfe0571dbe680e94bfc8d98b2aa135e73f84b26827e2f72d3fe97f1e5ccfb8f8bfe922fb6a6ddc073fdbf43cabf9f6c4bfc23a1d66e57d683fa16f93a5107320", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000104974ad3ff13210db66d4cc3ff06ff09a981f1a3ff26784b5e8fe073ff53c169b64a4f73ff0c994f9a236cb3ff015656ceb44683ff54d2939c6181c3ff4d6af82cb62c93ff0aa57053a2a1b3ff53844d9f98cc73ff0fc725b643e9c3ff03496a3af4d563ff00229b76fe61b3ff22d35b1a6f6b03ff1c2f9e05a83513ff2949f0aea731f3ff33e2373e7a4c53ff13d63c11ee4f83ff000156d64ce3c3ff49f55c513efd73ff09f068bb8c6323ff32382bde5abf53ff08ecf02bd06c23ff029ab606955a73ff2ac8e32a430fc3ff284e70a6af2213ff3c3f3000596813ff0011ab5d3c2a73ff0721c4fd1664b3ff490148a2bd9903ff0df56f3dabeaf", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-tanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfbee46032fe52773fd74e1af233c3d1bfddf718f5219c6c3fd91ac90f1935d7bfb4d65829a35a5cbfda4b83e7bf89233fe4dab1b34790593fdd6f8b6afecede3fe38a0aa112cc3ebfe34fbc988d59b7bfac2787891f65103fdc4e696100d9e9bfc8c9abb31b8e29bfd9b3a232017aa93fd343fadd7cf6793fdee904385cc1f83fdd214b34b35e92bfe2997dec11b6bebfc2d4520eee200ebfd4c2299e6710753fd7b75691eb781e3fe4f4bbd4d87858bfe2e3e4afaaa2843f7dfe963ad125ac3fe294717f500b23bfd40a063a3c15ed3fc31bdf754639a53fe12f2428857e2fbfe14bb86690b6c23fd666074260facfbfda0c3675ec1e62bfd29c4deaf85f05", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-asinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfbd5b8ff223eb51bfd337fdb364bdb13fdb4ef46374d476bfcada9ac78b85f33fe45a8b77c6151fbf785e4746f1bb75bfc63d341bc5c507bfe13c20959fd58c3fe366867168f59e3fe743c51d8a68ebbfe56c22cca534123fe0df9dd7cad652bfdba0741613dae23fc5dac93556d05abfe747a1942c59a5bfe25b465acc15d1bfd93601214bd4923fe12b26d8ad2d5abfe676c1277ceb793fdad985453f784e3fe0d4236e30ee3f3fe747f4579bc7233fdcf952239b20283fc2edb2836ea7a1bfe5bfd5bf1c797bbfe31455d60870e4bfe14f526aaa6c763fb2f2f9638a54793fb5d5fc414b90f33fc862a3bbc27b8e3fd09483edc9532a3fe14dd5a918344b", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-acosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe108a6b75517844004aabab23c133c4002c031bb5493803fd5364e30c4c35040049ee43f4963ee40020f5eda9b274240038517047c220a3ffde5873a7993aa4000ad6a99cb3c463ffb11590dce29b24002e9043bdfb3b24002d88c6bae7ec64002eb0defe4cad940041926694d64a24002c5f9ccd5d9623ffd253684fa8ea040047097138710b73ff39e9ab8989c5e4006050c707031464004c3102021eaf34000c8ebdfb31f8b400336136f0692bf400114520e1ddbd73ff7016eb7ea07ab40060ab1dafff62f4005c5bb216411644003354e66d05029400176395344c472400235b13a1b81723ffc0f415cd6a1e440031ff067f01a2d3fec7d0363f3cdbf", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-atanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe0350dcbbd2f4ebfcb488839fa5fcd3fdcf12f3c8b29d1bfe7188d3ed13b9d3fbfb6dedc329b99bfbdae05a0ad2154bfa3203b10965771bfe19fa143dfd2a43fcdbf2d1b3ffab8bfe4328c11bb09713fbd43f7412d7b503fe8f90785109f8abfe10a8144dc3b7ebfe0839e1feb9a1cbfae42b740dea087bf83af8e02375c7c3fb5468f370352b3bfe49b8f309239db3fca7acdaac03c87bfeea3a963619c1c3fe2f306f85c6d16bf7628e971fb015abfd8a5046350ec72bfc7a0fdedf51de8bfba7ff42c3345a8bfd3904555d14de23fef6ff9f2f06efa3fdaefe527d990b53fdf8f5ca686ebf03fe8fc384b032ca2bfed2b6521fe1badbfd45961e61e7795", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-erf-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfa5ed3b201e964d3fd3c600207a6e53bfb01bc434178b12bf9e5a98c565d19d3fe56750da2c74efbfda1c4ecc20f047bfb4c8726d4f2cc0bfde9fbdaeb47109bfd6f4ad2f537bf8bfc2cbd367b177d23fcf910ebf59bb6f3fb715414a9f4a1e3fd304d30ecb2daabfe63817610e3e843fe51fbfba6dc870bfdfa72d1fd5adf23fe4fec48063f6f8bfb8d42ab7abc5173fce5917af6536643f36dface3fa49babfa4c550012a6e79bfe3ee6a7650803c3fa4cf2ac187fc91bfe13a9f513203733fe78b8ec7356ef63fbb7ed121aec54f3fe5e1c7dbe2b37dbfc1ffb0f461e3d43fe04d26493232983fd4b5585f4228eebfdbde5e6d66692fbfe012885513e3fd", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-erfc-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffba9c30d961d143ff60c839f7dba803ff4f55d2271a8c63fd6365ee8699b2b3fd863728ba2d9a63fd7d26807cee88a3fd2e260396fc8a53ff3eabdc7e0d5023fdfffddd340f2b13fd762d8feda5a3d3fe895a539a274933fd110e7a988148d3ffb11b6d1a427ad3ffa7e6a80a800b93ff567a86641154a3ff34ff8c8381e323ff4af35c8d358a93ff6fcb92751b5f23ff93b1e0935214c3ff6b034359d41e73fde8a45f67859753ff83b8e393f4d0d3ff971758a42579b3ff5d33e2ff371883fe12ec95e7ead053fdb2eddb75393863ff915df9e12f1903fe5ec27c3a584bc3fd2f6c6ed730a2c3fe44656344073443ff995a6ac0af7873fe0c1432b1a2465", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sinpi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfeff938701472ae3fe2e2e9f3f11e833febe1753ef3d7c63fe03a112106abd73fe35e49907032113fd4f79031660e02bfeab501e15b4162bfee34937a9566f8bfeabbf9c1ce1a86bfe80c68fbe54d0cbfeffb3a434aff113fefba89814f470abfedcf1d965c96c43fe6d607c4623692bfed3732794cdb67bfedf475dbbfab04bfeffb3f02c7f0303fe0cbdf8d5c42343fea98a23b0bbfdcbfe6e58da49347d1bfee19c9716d4b51bfee64bc8317b3523fe828c2a37176a3bfeffee75d2280a0bfefc8fe21a32c0ebfed4642dc6f3bd2bfd06b077db262db3fe3fc1b486ebc2c3fefd61fbdc00fadbfec2e05885d6efcbfed77293142bf923fee928244579119", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cospi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fefa70dd5948ebc3fe3a726d3dadb773fe8ed4c466d9e163faab7dcaceb5a1abfd76625553b8d74bfd0ed208babf834bfd79923e3498e15bfc224c4bed2d2893fc9977f14c86b703fedd3c655ef24aa3fa7949b44f4ee403fefdf24f8a7c9163fc33e878c108d473feffe42e3ce3b133fe0a6c8644d71e6bfbe69c17675cb023fb173729518e024bfc10898c95080f53fd352dc6f3912d63fd21d64f21179973fb2d39f877b385bbf9abe29b571526bbfb7f6790e33f7efbfdd05c4d34fb088bfa2c57607c812d53fefa138219816be3fdbd8b289341e413fef795df9d9e15bbfe8d912ccb5c05c3fc5ac36e44951223fee107594b5bbc03fd79214bbbb7cf8", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-exp2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffae27d2096a6c93fef2f5d3d84e50e3fec5b3f2abc28423fee55ca76dc7ef83ff5f730810357933ff2ceb6751304373ff1c7ae6c5a34753ff0adf86ea4dff03fee0f6ee35a65843ff572de41dd5c523fec3beb529576793feaa4c2f40916e43ff231500dbb6f1c3ffaa504de2f566d3ff8ba158b7431673fe50468d67b1ca73fe9cc78ae3248813fe5498288db1af93fe5c249656065473fe72d757018ae7e3fe34c9728061eb93ff356310bcb54173fe2b574d142d74c3ff7daba58c613b83ff626e7d0219cf23ff00ca9681e045d3fe6cd6abc99449e3ff317ffedc0a6533fe625acdbdc0d7e3feefb972e29ced83ff41175a55f7a053ff78e95d6383efd", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-exp10-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff3ed1f5f4dcb654000c4578d6d9deb4007a2289bc9581840129305be3c9f2340045a4154e357753ffe700eb1a163a7401767f5072d30b63fe6825b80275034400280caddad77fe3ffb5010a95814e83fe247aaf8ca9af63fd74e818e87c07b400a953c0f62c8ba3fd0f756e2fa9a4a3fd0cabde6175a993fdd0b34681a9fc33fd0b888dd018ab63fe7e813ed3746243fc5c72a3dbef0513fca55b941f2418c3fe00a6c1a8b0c3740159f402cabd1f440020440dc2e472740088784ff604a243ff4d540f2c99e273fdea88bc1ed314c3fd307cd46ec42fb3fdb075167e5d09640012211d753de2f3ff673013b86d1f53fc45f625e5b008140150272c92030e1", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff29fbe641751003fed26677e1788d6400768ef5fb9d1924005e23f7eb4f3c23ff529dce2a5888040017de724950e2d4003e126060acd8bbfc5b73520c88248c00005973fe9c87d3fd91c30622e357940017edb9f9071eabffe529e22de7b38bfd5f1ad00e5bad1400768a3637ef71c3feccf7712578b4d3ffad8b626cc0a0a3f8493c24f41c00dbfffd998cbb07a8f3fd4b24ae4dd514f3fff176ba7adbd4240050f5ff894cfc940041887f1b5d89140000db4d601cde64000f89aced6f8613ffc5223ceb75e5b4005f45d94a94d82400438fbe0eb1d943ff7a8f510410ed63ff4692f8b6b36693ffdbb19ed448bcf400048455e10834b400076d0bb25565e", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cbrt-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfeb7d4503c104c4bfe76ecea145b6e3bfed0a33ec8d12db3fe79648c8c63988bfe7a0f8e6dbcd30bfe9f08eb6e28a03bfe57d5d7229d0c5bfe7ed121102471f3fecc742474a903a3fe2d1251d243576bfe8a54b32dd7a4bbfe254ffd86be0003feb0114e424d8af3fe381fa79b64389bfeca1c25b815d8d3feb0cd9dd71c6fb3fe48331b0cdcb2ebfe9d45d093eca04bfed01734200afd6bfe55af26ae40d953fd8bc538c4d09d13fe7a732b0d5ec423fe76d424692b09ebfe3f908aac730a7bfe851337d5ca477bfe3ff9f08b435813fe2a1eb9186c5853fd00839adaeded9bfea9356644bc7643fe9622b703cb9e33fe886b4fe33bc57bfeb7eed7076d914", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-lgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe054e856f6a1ba3fd6909cdeb44d1e400ead8575cb36553ff211f35814dc6f401bc283eb47440b400a04b8948099fd401b2451ab31bf143ff4db50ac67f7aa3ffe276976eca3013fe001a4439461664016a3c1e000b6f7bfb256c45c544278bfb7b7a4c19932d63ffa142d0efa57b9400c72f2c1ed33844012578ca4f6100d3ff7da23e77272403fcc822dfa34e40e400b750bf9bad006401c205c2cfbf1433ff1aadf17b1a02a4015bf4a64b48d81401a25726a7f1c64400d78e61b0b2b414011482dd4dc1a88bfbef0f9b7db1f2e40024a7cb89c5994400da5f6214f8f043fe5a9a9854c3a41400591b46550bf65400fc1bf9d0c22aa4009022b4742d636", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-tgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40a9549578418af53ffa60646bb9cd5a3fef52b1140a24db406ca1f88eba91c140af6baa57ecec7f3fecc2d3b32d39893fef6af566571f5340043b55adfaa0503fed475aa31da4a6401ec999eda8ceea4007c4c24d359fd9400b158668d4a19840b1a22d45d2c8543fecca1a9148f09d40038848a92db9004005c66940e59a514005dadfd39a775d4071d3a71984e40a4004f74f5597200e40888855bff0c86b3fedfbe6d79bcdca4090be895f176d363ff05b8c6d34d065408944b05798e0d13ff464c73275c2a03feccdff408e4fec408aa0b6051b9a9440a8d542b7433ffd40b1f10459c8a9c4407615eb71c6674f404e9cf096fb10d44000b3b12b59aca5", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-hypot-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "401ada0da261c1b03ffbcd4ee3604a18401e0bc024219ecc400b25b90b13db4d401f22153c4413a54015831fc7042b9b4002705eb6491582401545b1e7249dcc401e008b04a3cc73401df5dae63b9e213feb091416ce74644011bb1d12bff22440097781105d7a173fe2228c94a8b7d7401c763a3f983bb53fff5774891d31d340058a255e09c19140007ee90339c99d401a1ee2a0a93d41401ec222e7062d6d401cfe6fe9152a133fed2349edb2912c40033077a91205c8401582349ecf94cc401b82655f81cd49400f6dc9a8acfe97401b5339b0a4e9b54012a4eda263b2234018086fe6573aee401702d5263677f64008fca60be038a6401a5029fc336d5f", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-atan2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fa23a742b2419873fe4aec07c56878fbfb434166022448fbfa021969df11fa73fbc0a906e8f6ae3bfbff3586267569c3fb50d75ddda36053fb5a39f6a35f3bb3f9bbcda6927a81f3fe76f0fd9d3e0c43fc30301ab089fb23fc4e45fc4e8032bbfdc12944b321bdcbfcb733f706a0521bfc3fad50f96cd95bfb123960ab21916bf886c855abb17cd3fbb4ceab4a4b3023f8e3f6e86b581a93fcd80a3565250843fbed1a3c2ce0a103fb0f3750253ba723f8c99e52b42c9bbbfbb8d4cb3c58e613f89162cd21b8046bfb1c90fe95ca7d2bf832d0b37d722a93fe0a71ffcdf5e2d3fb6dd179e38f44d3fa7512ceb2c295c3fba5276c1d4ed803fab2cd062677ebb", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-logaddexp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff4379c961088c940173e485c6087c8401c4de3117064d3401ad5b80656be4540038f0ce893282b401382bbbc714c61401582ce924985a9401b0d88f4e61edc401d28d04de4e263400d1222a4bf6965401d169110496e1a400196971a6f2461401e78734004b7a0401afaeb4c6905cb4013d388cd078275401d736364b0b85640171ffd018c551c4001fcca12c7269540117fafdb2b9b2e401cd7c961d36d923ff7ab3b59aff84f400fcee405fd95264018ccd6a7b5c1384015d8441ea8f4c340126bbf874dcf3e402007f72ebc86cd401587aacd7c404d4015669a5892fcb9401277ec40202028401407314ea6b77d401b792a34ff6c9e4018a307a1c64193", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-fma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bffca1afbbaf3c103ff1443b35c2d0f0bfd54d30950a55b0bfd467db77e5c782400ea8c8acf18b3f3fa40af6b6f27fd2400348864b022ecebfd9b117a5af01d1bfeff2839101abba3fd3c41ec32a52f6bf73eba3634c6fc4c000b6950de331183ff08a80a957d73a400830321ca04bb74000297e0879e46bbffedfceef3c90a93feaa088e5da9f58bfe724ad8460a5e4c004da25d493889fc0061ca5ff2379043fe1a4632aad72a040031d28de85a32a3ff56a5ebc31c8a3c0064b1c47b8c6f7bfd578d85aa27a9bc00c3c592d4c0ec03ffc7ebdf56a7bbbbffe9648f89d233dbfe7532fcec84d01bfe952a969fe4b77bfba4faaac44a21a4010c2470a1811d2", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "interpreter", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + } + ] + }, + "on": { + "native": [ + { + "id": "signature-sin-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sin-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sin-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f576aa43f68c7b7" + } + }, + { + "id": "signature-sin-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446" + } + }, + { + "id": "signature-sin-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446" + } + }, + { + "id": "signature-sin-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sin-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f576aa43f68c7b7" + } + }, + { + "id": "signature-sin-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446" + } + }, + { + "id": "signature-sin-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446" + } + }, + { + "id": "signature-sin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f576aa43f68c7b7" + } + }, + { + "id": "signature-sin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446" + } + }, + { + "id": "signature-cos-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cos-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cos-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f0a5140bed51133" + } + }, + { + "id": "signature-cos-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205" + } + }, + { + "id": "signature-cos-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205" + } + }, + { + "id": "signature-cos-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cos-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f0a5140bed51133" + } + }, + { + "id": "signature-cos-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205" + } + }, + { + "id": "signature-cos-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205" + } + }, + { + "id": "signature-cos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f0a5140bed51133" + } + }, + { + "id": "signature-cos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205" + } + }, + { + "id": "signature-tan-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-tan-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-tan-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc75923c00bd7b1" + } + }, + { + "id": "signature-tan-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8" + } + }, + { + "id": "signature-tan-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8" + } + }, + { + "id": "signature-tan-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-tan-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc75923c00bd7b1" + } + }, + { + "id": "signature-tan-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8" + } + }, + { + "id": "signature-tan-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8" + } + }, + { + "id": "signature-tan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc75923c00bd7b1" + } + }, + { + "id": "signature-tan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8" + } + }, + { + "id": "signature-sinh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sinh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sinh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f966cfe40681e7b" + } + }, + { + "id": "signature-sinh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f" + } + }, + { + "id": "signature-sinh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f" + } + }, + { + "id": "signature-sinh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sinh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f966cfe40681e7b" + } + }, + { + "id": "signature-sinh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f" + } + }, + { + "id": "signature-sinh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f" + } + }, + { + "id": "signature-sinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f966cfe40681e7b" + } + }, + { + "id": "signature-sinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f" + } + }, + { + "id": "signature-cosh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cosh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cosh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fc583ab4070c7d0" + } + }, + { + "id": "signature-cosh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc" + } + }, + { + "id": "signature-cosh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc" + } + }, + { + "id": "signature-cosh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cosh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fc583ab4070c7d0" + } + }, + { + "id": "signature-cosh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc" + } + }, + { + "id": "signature-cosh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc" + } + }, + { + "id": "signature-cosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fc583ab4070c7d0" + } + }, + { + "id": "signature-cosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc" + } + }, + { + "id": "signature-tanh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-tanh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-tanh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f42f7d63f76ca83" + } + }, + { + "id": "signature-tanh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4" + } + }, + { + "id": "signature-tanh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4" + } + }, + { + "id": "signature-tanh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-tanh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f42f7d63f76ca83" + } + }, + { + "id": "signature-tanh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4" + } + }, + { + "id": "signature-tanh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4" + } + }, + { + "id": "signature-tanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f42f7d63f76ca83" + } + }, + { + "id": "signature-tanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4" + } + }, + { + "id": "signature-sqrt-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sqrt-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sqrt-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fb504f3" + } + }, + { + "id": "signature-sqrt-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd" + } + }, + { + "id": "signature-sqrt-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd" + } + }, + { + "id": "signature-sqrt-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sqrt-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fb504f3" + } + }, + { + "id": "signature-sqrt-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd" + } + }, + { + "id": "signature-sqrt-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd" + } + }, + { + "id": "signature-sqrt-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fb504f3" + } + }, + { + "id": "signature-sqrt-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd" + } + }, + { + "id": "signature-cbrt-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cbrt-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cbrt-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fa14518" + } + }, + { + "id": "signature-cbrt-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b" + } + }, + { + "id": "signature-cbrt-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b" + } + }, + { + "id": "signature-cbrt-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-cbrt-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fa14518" + } + }, + { + "id": "signature-cbrt-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b" + } + }, + { + "id": "signature-cbrt-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b" + } + }, + { + "id": "signature-cbrt-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fa14518" + } + }, + { + "id": "signature-cbrt-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b" + } + }, + { + "id": "signature-exp-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-exp-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-exp-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f800000402df85440ec7326" + } + }, + { + "id": "signature-exp-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae" + } + }, + { + "id": "signature-exp-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae" + } + }, + { + "id": "signature-exp-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-exp-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f800000402df85440ec7326" + } + }, + { + "id": "signature-exp-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae" + } + }, + { + "id": "signature-exp-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae" + } + }, + { + "id": "signature-exp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f800000402df85440ec7326" + } + }, + { + "id": "signature-exp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae" + } + }, + { + "id": "signature-exp2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-exp2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-exp2-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040800000" + } + }, + { + "id": "signature-exp2-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000" + } + }, + { + "id": "signature-exp2-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000" + } + }, + { + "id": "signature-exp2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-exp2-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040800000" + } + }, + { + "id": "signature-exp2-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000" + } + }, + { + "id": "signature-exp2-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000" + } + }, + { + "id": "signature-exp2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040800000" + } + }, + { + "id": "signature-exp2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000" + } + }, + { + "id": "signature-expm1-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-expm1-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-expm1-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fdbf0a940cc7326" + } + }, + { + "id": "signature-expm1-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae" + } + }, + { + "id": "signature-expm1-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae" + } + }, + { + "id": "signature-expm1-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-expm1-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fdbf0a940cc7326" + } + }, + { + "id": "signature-expm1-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae" + } + }, + { + "id": "signature-expm1-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae" + } + }, + { + "id": "signature-expm1-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fdbf0a940cc7326" + } + }, + { + "id": "signature-expm1-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae" + } + }, + { + "id": "signature-log-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218" + } + }, + { + "id": "signature-log-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-log-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-log-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218" + } + }, + { + "id": "signature-log-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-log-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-log-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218" + } + }, + { + "id": "signature-log-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-log2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log2-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f800000" + } + }, + { + "id": "signature-log2-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "signature-log2-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "signature-log2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log2-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f800000" + } + }, + { + "id": "signature-log2-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "signature-log2-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "signature-log2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f800000" + } + }, + { + "id": "signature-log2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "signature-log10-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log10-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log10-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003e9a209b" + } + }, + { + "id": "signature-log10-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff" + } + }, + { + "id": "signature-log10-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff" + } + }, + { + "id": "signature-log10-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log10-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003e9a209b" + } + }, + { + "id": "signature-log10-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff" + } + }, + { + "id": "signature-log10-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff" + } + }, + { + "id": "signature-log10-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003e9a209b" + } + }, + { + "id": "signature-log10-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff" + } + }, + { + "id": "signature-log1p-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log1p-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log1p-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f3172183f8c9f54" + } + }, + { + "id": "signature-log1p-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b" + } + }, + { + "id": "signature-log1p-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b" + } + }, + { + "id": "signature-log1p-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-log1p-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f3172183f8c9f54" + } + }, + { + "id": "signature-log1p-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b" + } + }, + { + "id": "signature-log1p-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b" + } + }, + { + "id": "signature-log1p-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f3172183f8c9f54" + } + }, + { + "id": "signature-log1p-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b" + } + }, + { + "id": "signature-ceil-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-ceil-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-ceil-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-ceil-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-ceil-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-ceil-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-ceil-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-ceil-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-ceil-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-ceil-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-ceil-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-floor-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-floor-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-floor-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-floor-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-floor-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-floor-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-floor-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-floor-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-floor-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-floor-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-floor-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-trunc-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-trunc-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-trunc-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-trunc-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-trunc-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-trunc-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-trunc-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-trunc-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-trunc-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-trunc-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-trunc-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-rint-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-rint-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-rint-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-rint-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-rint-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-rint-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-rint-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-rint-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-rint-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-rint-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-rint-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-round-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-round-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-round-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-round-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-round-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-round-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-round-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-round-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-round-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-round-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-round-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-sign-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-sign-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-sign-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "signature-sign-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "signature-sign-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "signature-sign-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-sign-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + } + }, + { + "id": "signature-sign-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + } + }, + { + "id": "signature-sign-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + } + }, + { + "id": "signature-sign-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000" + } + }, + { + "id": "signature-sign-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000" + } + }, + { + "id": "signature-square-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-square-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + } + }, + { + "id": "signature-square-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + } + }, + { + "id": "signature-square-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + } + }, + { + "id": "signature-square-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + } + }, + { + "id": "signature-square-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + } + }, + { + "id": "signature-square-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + } + }, + { + "id": "signature-square-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + } + }, + { + "id": "signature-square-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + } + }, + { + "id": "signature-square-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040800000" + } + }, + { + "id": "signature-square-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004010000000000000" + } + }, + { + "id": "signature-conj-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-conj-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-conj-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-conj-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-conj-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-conj-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-conj-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-conj-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-conj-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-conj-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-conj-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-real-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-real-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-real-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-real-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-real-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-real-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-real-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-real-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-real-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-real-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-real-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-imag-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-imag-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-imag-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "signature-imag-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-imag-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-imag-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-imag-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "signature-imag-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-imag-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-imag-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-imag-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-isfinite-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isfinite-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-isinf-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isinf-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-isnan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-signbit-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-fabs-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-fabs-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-fabs-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-fabs-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-fabs-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-fabs-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-fabs-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-fabs-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-fabs-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-fabs-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-fabs-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-absolute-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-absolute-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-absolute-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-absolute-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-absolute-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-absolute-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-absolute-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-absolute-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-absolute-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-absolute-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-absolute-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-abs-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-abs-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-abs-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-abs-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-abs-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-abs-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 3, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-abs-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-abs-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-abs-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-abs-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-abs-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-ln-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-ln-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-ln-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218" + } + }, + { + "id": "signature-ln-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-ln-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-ln-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-ln-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218" + } + }, + { + "id": "signature-ln-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-ln-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-ln-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218" + } + }, + { + "id": "signature-ln-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef" + } + }, + { + "id": "signature-acos-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-acos-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-acos-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000" + } + }, + { + "id": "signature-acos-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-acos-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-acos-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-acos-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000" + } + }, + { + "id": "signature-acos-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-acos-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-acos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000" + } + }, + { + "id": "signature-acos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-asin-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-asin-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-asin-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000" + } + }, + { + "id": "signature-asin-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-asin-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-asin-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-asin-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000" + } + }, + { + "id": "signature-asin-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-asin-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-asin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000" + } + }, + { + "id": "signature-asin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-atan-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atan-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atan-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d" + } + }, + { + "id": "signature-atan-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-atan-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-atan-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atan-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d" + } + }, + { + "id": "signature-atan-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-atan-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-atan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d" + } + }, + { + "id": "signature-atan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-acosh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-acosh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-acosh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214" + } + }, + { + "id": "signature-acosh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-acosh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-acosh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-acosh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214" + } + }, + { + "id": "signature-acosh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-acosh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-acosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214" + } + }, + { + "id": "signature-acosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-asinh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-asinh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-asinh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c" + } + }, + { + "id": "signature-asinh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-asinh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-asinh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-asinh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c" + } + }, + { + "id": "signature-asinh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-asinh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-asinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c" + } + }, + { + "id": "signature-asinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-atanh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atanh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atanh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000" + } + }, + { + "id": "signature-atanh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-atanh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-atanh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atanh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000" + } + }, + { + "id": "signature-atanh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-atanh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-atanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000" + } + }, + { + "id": "signature-atanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-arccos-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arccos-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arccos-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000" + } + }, + { + "id": "signature-arccos-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-arccos-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-arccos-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arccos-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000" + } + }, + { + "id": "signature-arccos-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-arccos-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-arccos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000" + } + }, + { + "id": "signature-arccos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000" + } + }, + { + "id": "signature-arcsin-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arcsin-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arcsin-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000" + } + }, + { + "id": "signature-arcsin-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-arcsin-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-arcsin-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arcsin-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000" + } + }, + { + "id": "signature-arcsin-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-arcsin-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-arcsin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000" + } + }, + { + "id": "signature-arcsin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000" + } + }, + { + "id": "signature-arctan-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctan-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctan-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d" + } + }, + { + "id": "signature-arctan-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-arctan-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-arctan-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctan-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d" + } + }, + { + "id": "signature-arctan-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-arctan-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-arctan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d" + } + }, + { + "id": "signature-arctan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45" + } + }, + { + "id": "signature-arccosh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arccosh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arccosh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214" + } + }, + { + "id": "signature-arccosh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-arccosh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-arccosh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arccosh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214" + } + }, + { + "id": "signature-arccosh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-arccosh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-arccosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214" + } + }, + { + "id": "signature-arccosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434" + } + }, + { + "id": "signature-arcsinh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arcsinh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arcsinh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c" + } + }, + { + "id": "signature-arcsinh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-arcsinh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-arcsinh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arcsinh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c" + } + }, + { + "id": "signature-arcsinh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-arcsinh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-arcsinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c" + } + }, + { + "id": "signature-arcsinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087" + } + }, + { + "id": "signature-arctanh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctanh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctanh-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000" + } + }, + { + "id": "signature-arctanh-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-arctanh-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-arctanh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctanh-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000" + } + }, + { + "id": "signature-arctanh-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-arctanh-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-arctanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000" + } + }, + { + "id": "signature-arctanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "signature-minimum-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-minimum-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-minimum-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-minimum-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-minimum-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-minimum-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-minimum-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-minimum-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-minimum-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-minimum-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-minimum-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-maximum-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-maximum-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "signature-maximum-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "signature-maximum-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "signature-maximum-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "signature-maximum-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "signature-maximum-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "signature-maximum-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "signature-maximum-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "signature-maximum-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "signature-maximum-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-fmin-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-fmin-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-fmin-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-fmin-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-fmin-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-fmin-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-fmin-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-fmin-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-fmin-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-fmin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-fmin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-fmax-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + } + }, + { + "id": "signature-fmax-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "signature-fmax-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "signature-fmax-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "signature-fmax-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "signature-fmax-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + } + }, + { + "id": "signature-fmax-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + } + }, + { + "id": "signature-fmax-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + } + }, + { + "id": "signature-fmax-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + } + }, + { + "id": "signature-fmax-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000" + } + }, + { + "id": "signature-fmax-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-hypot-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-hypot-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-hypot-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fb504f3403504f3" + } + }, + { + "id": "signature-hypot-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd" + } + }, + { + "id": "signature-hypot-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd" + } + }, + { + "id": "signature-hypot-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-hypot-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fb504f3403504f3" + } + }, + { + "id": "signature-hypot-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd" + } + }, + { + "id": "signature-hypot-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd" + } + }, + { + "id": "signature-hypot-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fb504f3403504f3" + } + }, + { + "id": "signature-hypot-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd" + } + }, + { + "id": "signature-copysign-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-copysign-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-copysign-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-copysign-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-copysign-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-copysign-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-copysign-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-copysign-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-copysign-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-copysign-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-copysign-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "signature-nextafter-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-nextafter-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-nextafter-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000013f80000040000000" + } + }, + { + "id": "signature-nextafter-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000" + } + }, + { + "id": "signature-nextafter-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000" + } + }, + { + "id": "signature-nextafter-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-nextafter-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000013f80000040000000" + } + }, + { + "id": "signature-nextafter-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000" + } + }, + { + "id": "signature-nextafter-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000" + } + }, + { + "id": "signature-nextafter-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000013f80000040000000" + } + }, + { + "id": "signature-nextafter-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000" + } + }, + { + "id": "signature-logaddexp-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-logaddexp-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-logaddexp-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fa818f63fd8b90c402c5c86" + } + }, + { + "id": "signature-logaddexp-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c" + } + }, + { + "id": "signature-logaddexp-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c" + } + }, + { + "id": "signature-logaddexp-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-logaddexp-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fa818f63fd8b90c402c5c86" + } + }, + { + "id": "signature-logaddexp-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c" + } + }, + { + "id": "signature-logaddexp-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c" + } + }, + { + "id": "signature-logaddexp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fa818f63fd8b90c402c5c86" + } + }, + { + "id": "signature-logaddexp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c" + } + }, + { + "id": "signature-fmod-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-fmod-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-fmod-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "signature-fmod-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-fmod-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-fmod-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-fmod-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "signature-fmod-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-fmod-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-fmod-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-fmod-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-remainder-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-remainder-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-remainder-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "signature-remainder-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-remainder-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-remainder-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + } + }, + { + "id": "signature-remainder-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + } + }, + { + "id": "signature-remainder-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-remainder-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-remainder-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + } + }, + { + "id": "signature-remainder-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + } + }, + { + "id": "signature-power-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-power-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + } + }, + { + "id": "signature-power-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + } + }, + { + "id": "signature-power-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + } + }, + { + "id": "signature-power-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + } + }, + { + "id": "signature-power-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + } + }, + { + "id": "signature-power-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + } + }, + { + "id": "signature-power-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + } + }, + { + "id": "signature-power-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + } + }, + { + "id": "signature-power-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040800000" + } + }, + { + "id": "signature-power-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004010000000000000" + } + }, + { + "id": "signature-ldexp-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-ldexp-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-ldexp-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000004000000041000000" + } + }, + { + "id": "signature-ldexp-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000" + } + }, + { + "id": "signature-ldexp-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000" + } + }, + { + "id": "signature-ldexp-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-ldexp-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 18, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000004000000041000000" + } + }, + { + "id": "signature-ldexp-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000" + } + }, + { + "id": "signature-ldexp-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000" + } + }, + { + "id": "signature-ldexp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000004000000041000000" + } + }, + { + "id": "signature-ldexp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 36, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000" + } + }, + { + "id": "signature-atan2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atan2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atan2-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb" + } + }, + { + "id": "signature-atan2-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-atan2-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-atan2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-atan2-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb" + } + }, + { + "id": "signature-atan2-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-atan2-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-atan2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb" + } + }, + { + "id": "signature-atan2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-arctan2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctan2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctan2-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb" + } + }, + { + "id": "signature-arctan2-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-arctan2-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-arctan2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-arctan2-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb" + } + }, + { + "id": "signature-arctan2-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-arctan2-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-arctan2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb" + } + }, + { + "id": "signature-arctan2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18" + } + }, + { + "id": "signature-pow-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-pow-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + } + }, + { + "id": "signature-pow-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + } + }, + { + "id": "signature-pow-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + } + }, + { + "id": "signature-pow-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + } + }, + { + "id": "signature-pow-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + } + }, + { + "id": "signature-pow-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + } + }, + { + "id": "signature-pow-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + } + }, + { + "id": "signature-pow-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + } + }, + { + "id": "signature-pow-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040800000" + } + }, + { + "id": "signature-pow-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004010000000000000" + } + }, + { + "id": "signature-extension-erf-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-erf-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-erf-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f57bb3d3f57bb3d" + } + }, + { + "id": "signature-extension-erf-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a" + } + }, + { + "id": "signature-extension-erf-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a" + } + }, + { + "id": "signature-extension-erf-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-erf-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f57bb3d3f57bb3d" + } + }, + { + "id": "signature-extension-erf-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a" + } + }, + { + "id": "signature-extension-erf-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a" + } + }, + { + "id": "signature-extension-erf-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f57bb3d3f57bb3d" + } + }, + { + "id": "signature-extension-erf-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a" + } + }, + { + "id": "signature-extension-erfc-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-erfc-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-erfc-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3e21130b3e21130b" + } + }, + { + "id": "signature-extension-erfc-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6" + } + }, + { + "id": "signature-extension-erfc-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6" + } + }, + { + "id": "signature-extension-erfc-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-erfc-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3e21130b3e21130b" + } + }, + { + "id": "signature-extension-erfc-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6" + } + }, + { + "id": "signature-extension-erfc-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6" + } + }, + { + "id": "signature-extension-erfc-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3e21130b3e21130b" + } + }, + { + "id": "signature-extension-erfc-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6" + } + }, + { + "id": "signature-extension-lgamma-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-lgamma-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-lgamma-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-lgamma-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-lgamma-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-lgamma-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-lgamma-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-lgamma-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-lgamma-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-lgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-lgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-tgamma-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-tgamma-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-tgamma-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f800000" + } + }, + { + "id": "signature-extension-tgamma-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000" + } + }, + { + "id": "signature-extension-tgamma-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000" + } + }, + { + "id": "signature-extension-tgamma-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-tgamma-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f800000" + } + }, + { + "id": "signature-extension-tgamma-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000" + } + }, + { + "id": "signature-extension-tgamma-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000" + } + }, + { + "id": "signature-extension-tgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f800000" + } + }, + { + "id": "signature-extension-tgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000" + } + }, + { + "id": "signature-extension-exp10-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-exp10-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-exp10-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4120000041200000" + } + }, + { + "id": "signature-extension-exp10-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000" + } + }, + { + "id": "signature-extension-exp10-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000" + } + }, + { + "id": "signature-extension-exp10-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-exp10-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4120000041200000" + } + }, + { + "id": "signature-extension-exp10-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000" + } + }, + { + "id": "signature-extension-exp10-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000" + } + }, + { + "id": "signature-extension-exp10-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4120000041200000" + } + }, + { + "id": "signature-extension-exp10-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000" + } + }, + { + "id": "signature-extension-sinpi-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-sinpi-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-sinpi-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-sinpi-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-sinpi-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-sinpi-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-sinpi-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-sinpi-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-sinpi-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-sinpi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-sinpi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-cospi-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-cospi-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-cospi-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000" + } + }, + { + "id": "signature-extension-cospi-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000" + } + }, + { + "id": "signature-extension-cospi-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000" + } + }, + { + "id": "signature-extension-cospi-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-cospi-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000" + } + }, + { + "id": "signature-extension-cospi-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000" + } + }, + { + "id": "signature-extension-cospi-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000" + } + }, + { + "id": "signature-extension-cospi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000" + } + }, + { + "id": "signature-extension-cospi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000" + } + }, + { + "id": "signature-extension-fdim-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-fdim-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-fdim-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-fdim-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-fdim-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-fdim-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-fdim-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-fdim-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-fdim-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-fdim-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "signature-extension-fdim-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000" + } + }, + { + "id": "signature-extension-fma-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 6, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 12, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4000000040000000" + } + }, + { + "id": "signature-extension-fma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000" + } + }, + { + "id": "signature-extension-fac-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-fac-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + } + }, + { + "id": "signature-extension-fac-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "signature-extension-fac-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + } + }, + { + "id": "signature-extension-fac-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-fac-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + } + }, + { + "id": "signature-extension-fac-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "signature-extension-fac-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + } + }, + { + "id": "signature-extension-fac-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-fac-float32", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-fac-float64", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-ncr-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-ncr-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + } + }, + { + "id": "signature-extension-ncr-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "signature-extension-ncr-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + } + }, + { + "id": "signature-extension-ncr-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-ncr-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + } + }, + { + "id": "signature-extension-ncr-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "signature-extension-ncr-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + } + }, + { + "id": "signature-extension-ncr-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-ncr-float32", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-ncr-float64", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-npr-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-npr-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + } + }, + { + "id": "signature-extension-npr-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "signature-extension-npr-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + } + }, + { + "id": "signature-extension-npr-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-npr-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + } + }, + { + "id": "signature-extension-npr-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + } + }, + { + "id": "signature-extension-npr-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + } + }, + { + "id": "signature-extension-npr-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + } + }, + { + "id": "signature-extension-npr-float32", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-npr-float64", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "signature-extension-e-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-e-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "signature-extension-pi-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 2, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 4, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-extension-pi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18" + } + }, + { + "id": "signature-where-bool", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + } + }, + { + "id": "signature-where-int8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-where-int16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-where-int32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-where-int64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 51, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-where-uint8", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 9, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + } + }, + { + "id": "signature-where-uint16", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 15, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + } + }, + { + "id": "signature-where-uint32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + } + }, + { + "id": "signature-where-uint64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 51, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + } + }, + { + "id": "signature-where-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000" + } + }, + { + "id": "signature-where-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 51, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000" + } + }, + { + "id": "exceptional-sin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f0599b3bf68c7b7bf576aa4bef57744800000000000000000000001008000003ef577443f576aa43f68c7b7bf0599b37fc000007fc00000" + } + }, + { + "id": "exceptional-cos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f5a5f96bed511333f0a51403f60a9403f8000003f8000003f8000003f8000003f60a9403f0a5140bed511333f5a5f967fc000007fc00000" + } + }, + { + "id": "exceptional-tan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f1c9eca400bd7b1bfc75923bf0bda7b800000000000000000000001008000003f0bda7b3fc75923c00bd7b1bf1c9eca7fc000007fc00000" + } + }, + { + "id": "exceptional-sinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff800000c0681e7bbf966cfebf056680800000000000000000000001008000003f0566803f966cfe40681e7b7f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-cosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f8000004070c7d03fc583ab3f90560c3f8000003f8000003f8000003f8000003f90560c3fc583ab4070c7d07f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-tanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf76ca83bf42f7d6beec9a9f800000000000000000000001008000003eec9a9f3f42f7d63f76ca833f8000003f8000007fc00000" + } + }, + { + "id": "exceptional-sqrt-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc0000080000000000000001a3504f3200000003f3504f33f8000003fb504f35f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-cbrt-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000d4cb2ff5bfa14518bf800000bf4b2ff5800000000000000026a145182a8000003f4b2ff53f8000003fa1451854cb2ff57f8000007fc00000" + } + }, + { + "id": "exceptional-exp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003e0a95553ebc5ab23f1b45983f8000003f8000003f8000003f8000003fd3094c402df85440ec73267f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-exp2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003e8000003f0000003f3504f33f8000003f8000003f8000003f8000003fb504f340000000408000007f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-expm1-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf5d5aabbf21d2a7bec974d0800000000000000000000001008000003f2612993fdbf0a940cc73267f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-log-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c2ce8ed0c2aeac50bf317218000000003f31721842b172187f8000007fc00000" + } + }, + { + "id": "exceptional-log2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c3150000c2fc0000bf800000000000003f800000430000007f8000007fc00000" + } + }, + { + "id": "exceptional-log10-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c23369f4c217b818be9a209b000000003e9a209b421a209b7f8000007fc00000" + } + }, + { + "id": "exceptional-log1p-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000ff800000bf317218800000000000000000000001008000003ecf991f3f3172183f8c9f5442b172187f8000007fc00000" + } + }, + { + "id": "exceptional-ceil-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000003f8000003f8000003f8000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-floor-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf80000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-trunc-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-rint-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-round-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-sign-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf800000bf800000bf80000000000000000000003f8000003f8000003f8000003f8000003f8000003f8000003f8000007fc00000" + } + }, + { + "id": "exceptional-square-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f800000408000003f8000003e800000000000000000000000000000000000003e8000003f800000408000007f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-conj-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf000000800000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-real-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf000000800000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-imag-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "id": "exceptional-isfinite-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000101010101010101010101010000" + } + }, + { + "id": "exceptional-isinf-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010000000000000000000000000100" + } + }, + { + "id": "exceptional-isnan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000001" + } + }, + { + "id": "exceptional-signbit-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010101010101000000000000000000" + } + }, + { + "id": "exceptional-fabs-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f8000003f000000000000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-absolute-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f8000003f000000000000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-abs-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f8000003f000000000000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-ln-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c2ce8ed0c2aeac50bf317218000000003f31721842b172187f8000007fc00000" + } + }, + { + "id": "exceptional-acos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc0000040490fda40060a923fc90fdb3fc90fdb3fc90fdb3fc90fdb3f860a92000000007fc000007fc000007fc000007fc00000" + } + }, + { + "id": "exceptional-asin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000bfc90fdabf060a92800000000000000000000001008000003f060a923fc90fda7fc000007fc000007fc000007fc00000" + } + }, + { + "id": "exceptional-atan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bfc90fdabfc90fdabf8db70dbf490fdbbeed6338800000000000000000000001008000003eed63383f490fdb3f8db70d3fc90fda3fc90fda7fc00000" + } + }, + { + "id": "exceptional-acosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc00000000000003fa8921442b2d4fc7f8000007fc00000" + } + }, + { + "id": "exceptional-asinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000c2b2d4fcbfb8c90cbf61a1b3bef66165800000000000000000000001008000003ef661653f61a1b33fb8c90c42b2d4fc7f8000007fc00000" + } + }, + { + "id": "exceptional-atanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000ff800000bf0c9f54800000000000000000000001008000003f0c9f547f8000007fc000007fc000007fc000007fc00000" + } + }, + { + "id": "exceptional-arccos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc0000040490fda40060a923fc90fdb3fc90fdb3fc90fdb3fc90fdb3f860a92000000007fc000007fc000007fc000007fc00000" + } + }, + { + "id": "exceptional-arcsin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000bfc90fdabf060a92800000000000000000000001008000003f060a923fc90fda7fc000007fc000007fc000007fc00000" + } + }, + { + "id": "exceptional-arctan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bfc90fdabfc90fdabf8db70dbf490fdbbeed6338800000000000000000000001008000003eed63383f490fdb3f8db70d3fc90fda3fc90fda7fc00000" + } + }, + { + "id": "exceptional-arccosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc00000000000003fa8921442b2d4fc7f8000007fc00000" + } + }, + { + "id": "exceptional-arcsinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000c2b2d4fcbfb8c90cbf61a1b3bef66165800000000000000000000001008000003ef661653f61a1b33fb8c90c42b2d4fc7f8000007fc00000" + } + }, + { + "id": "exceptional-arctanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000ff800000bf0c9f54800000000000000000000001008000003f0c9f547f8000007fc000007fc000007fc000007fc00000" + } + }, + { + "id": "exceptional-minimum-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000ff7fffffc0000000bf800000bf000000800000008000000000000001000000013f000000bf80000040000000ff7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-maximum-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000000000000000000000400000008000000000000000000000000080000000800000400000003f8000007f8000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-fmin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf000000800000008000000000000001000000013f000000bf80000040000000ff7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-fmax-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff8000000000000000000000400000008000000000000000000000000080000000800000400000003f8000007f8000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-hypot-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff40000000400f1bbd3f000000000000000000000000800000008000004003f07b3fb504f37f8000007f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-copysign-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f800000bf000000000000008000000000000001008000003f000000bf80000040000000ff7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-nextafter-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000ff7ffffebfffffffbf7fffffbeffffff000000008000000000000002007fffff3f0000013f7fffff400000017f7ffffe7f8000007fc00000" + } + }, + { + "id": "exceptional-logaddexp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003e01f96b40031c0e3ef2ba383f3172183f3172183f3172183f317218400ce3f53f903f2d7f8000007f7fffff7f8000007fc00000" + } + }, + { + "id": "exceptional-fmod-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000bf8000007fc000007fc000007fc0000000000001000000003f0000000000000040000000000000007fc000007fc00000" + } + }, + { + "id": "exceptional-remainder-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000003f8000007fc000007fc000007fc0000000000001000000003f0000008000000040000000800000007fc000007fc00000" + } + }, + { + "id": "exceptional-power-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003e8000003f8000007f800000000000007f8000007fc00000" + } + }, + { + "id": "exceptional-ldexp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff800000bf800000bf800000bf800000800000000000000000000000004000003f8000007f8000007f8000007f8000007f8000007fc00000" + } + }, + { + "id": "exceptional-atan2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000bfc90fdbbfc90fdbbeed6338bfc90fdb8000000040490fda340000003fc90fda3e7adbb04016cbe4000000004016cbe43f490fdb7fc00000" + } + }, + { + "id": "exceptional-arctan2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000bfc90fdbbfc90fdbbeed6338bfc90fdb8000000040490fda340000003fc90fda3e7adbb04016cbe4000000004016cbe43f490fdb7fc00000" + } + }, + { + "id": "exceptional-pow-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003e8000003f8000007f800000000000007f8000007fc00000" + } + }, + { + "id": "ties-rint-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c0800000c0000000c00000008000000000000000400000004000000040800000" + } + }, + { + "id": "ties-round-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c0800000c0000000c00000008000000000000000400000004000000040800000" + } + }, + { + "id": "extension-erf-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3e8d7aa73f053f7b3f57bb3d3f7ecd71" + } + }, + { + "id": "extension-exceptional-erf-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf7ecd71bf57bb3dbf053f7b80000000000000000000000100906ebb3f053f7b3f57bb3d3f7ecd713f8000003f8000007fc00000" + } + }, + { + "id": "extension-erfc-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3f3942ac3ef5810a3e21130b3b9947af" + } + }, + { + "id": "extension-exceptional-erfc-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "40000000400000003fff66b83febdd9f3fc29fbe3f8000003f8000003f8000003f8000003ef5810a3e21130b3b9947af00000000000000007fc00000" + } + }, + { + "id": "extension-lgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fa4ddec3f1286820000000000000000" + } + }, + { + "id": "extension-exceptional-lgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f8000007f8000007f8000003fa1fc4d7f8000007f80000042ce8ed042aeac503f12868200000000000000007f8000007f8000007fc00000" + } + }, + { + "id": "extension-tgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "406809fe3fe2dfc53f8000003f800000" + } + }, + { + "id": "extension-exceptional-tgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc00000c062dfc5ff8000007f8000007f8000007e8000003fe2dfc53f8000003f8000007f8000007f8000007fc00000" + } + }, + { + "id": "extension-exp10-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe39ea9404a62c24120000042c80000" + } + }, + { + "id": "extension-exceptional-exp10-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003c23d70a3dcccccd3ea1e89b3f8000003f8000003f8000003f800000404a62c24120000042c800007f8000007f8000007fc00000" + } + }, + { + "id": "extension-sinpi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3f3504f33f8000000000000000000000" + } + }, + { + "id": "extension-exceptional-sinpi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000800000008000000080000000bf80000080000000000000000000000301490fdb3f8000000000000000000000000000007fc000007fc00000" + } + }, + { + "id": "extension-cospi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3f3504f300000000bf8000003f800000" + } + }, + { + "id": "extension-exceptional-cospi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 60, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f8000003f800000bf800000000000003f8000003f8000003f8000003f80000000000000bf8000003f8000003f8000007fc000007fc00000" + } + }, + { + "id": "extension-fdim-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000003f800000" + } + }, + { + "id": "extension-exceptional-fdim-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc0000000000000000000000000000000000000000000000000000000000000007fffff0000000040000000000000007f800000000000007fc00000" + } + }, + { + "id": "extension-fma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "bf400000bf000000000000003f800000" + } + }, + { + "id": "extension-exceptional-fma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 180, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000000000000000000000c000000000000000000000000000000000000000000000003f800000bf8000007f800000ff8000007f8000007fc00000" + } + }, + { + "id": "extension-fac-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000060000000000000018" + } + }, + { + "id": "extension-ncr-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 64, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + } + }, + { + "id": "extension-npr-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 64, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + } + }, + { + "id": "extension-e-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b1457694005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "extension-pi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18400921fb54442d18400921fb54442d18" + } + }, + { + "id": "exceptional-sin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bf7452fc98b34e97bfed18f6ead1b446bfeaed548f090ceebfdeaee8744b05f080000000000000000000000000000000000000000000000100100000000000003fdeaee8744b05f03feaed548f090cee3fed18f6ead1b4463f7452fc98b34e977ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-cos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bfefffe62ecfab75bfdaa226575372053fe14a280fb5068c3fec1528065b7d503ff00000000000003ff00000000000003ff00000000000003ff00000000000003fec1528065b7d503fe14a280fb5068cbfdaa22657537205bfefffe62ecfab757ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-tan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003f74530cfe72948340017af62e0950f8bff8eb245cbee3a5bfe17b4f5bf3474a80000000000000000000000000000000000000000000000100100000000000003fe17b4f5bf3474a3ff8eb245cbee3a5c0017af62e0950f8bf74530cfe7294837ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-sinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000fff0000000000000c00d03cf63b6e19fbff2cd9fc44eb982bfe0acd00fe63b9780000000000000000000000000000000000000000000000100100000000000003fe0acd00fe63b973ff2cd9fc44eb982400d03cf63b6e19f7ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-cosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007ff0000000000000400e18fa0df2d9bc3ff8b07551d9f5503ff20ac1862ae8d03ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff20ac1862ae8d03ff8b07551d9f550400e18fa0df2d9bc7ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-tanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bfeed9505e1bc3d4bfe85efab514f394bfdd9353d7568af380000000000000000000000000000000000000000000000100100000000000003fdd9353d7568af33fe85efab514f3943feed9505e1bc3d43ff00000000000003ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-sqrt-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000800000000000000000000000000000001e6000000000000020000000000000003fe6a09e667f3bcd3ff00000000000003ff6a09e667f3bcd5fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-cbrt-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000d54428a2f98d728bbff428a2f98d728bbff0000000000000bfe965fea53d6e3d8000000000000000000000000000000029900000000000002aa428a2f98d728b3fe965fea53d6e3d3ff00000000000003ff428a2f98d728b554428a2f98d728b7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-exp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003fc152aaa3bf81cc3fd78b56362cef383fe368b2fc6f960a3ff00000000000003ff00000000000003ff00000000000003ff00000000000003ffa61298e1e069c4005bf0a8b145769401d8e64b8d4ddae7ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-exp2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003fd00000000000003fe00000000000003fe6a09e667f3bcd3ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff6a09e667f3bcd400000000000000040100000000000007ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-expm1-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bfebab5557101f8dbfe43a54e4e98864bfd92e9a0720d3ec80000000000000000000000000000000000000000000000100100000000000003fe4c2531c3c0d383ffb7e151628aed340198e64b8d4ddae7ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-log-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c0874385446d71c3c086232bdd7abcd2bfe62e42fefa39ef00000000000000003fe62e42fefa39ef40862e42fefa39ef7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-log2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c090c80000000000c08ff00000000000bff000000000000000000000000000003ff000000000000040900000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-log10-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c07434e6420f4374c0733a7146f72a42bfd34413509f79ff00000000000000003fd34413509f79ff40734413509f79ff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-log1p-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000fff0000000000000bfe62e42fefa39ef80000000000000000000000000000000000000000000000100100000000000003fd9f323ecbf984c3fe62e42fefa39ef3ff193ea7aad030b40862e42fefa39ef7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-ceil-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000003ff00000000000003ff00000000000003ff00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-floor-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bff0000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-trunc-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-rint-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-round-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-sign-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bff0000000000000bff0000000000000bff0000000000000000000000000000000000000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-square-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007ff000000000000040100000000000003ff00000000000003fd000000000000000000000000000000000000000000000000000000000000000000000000000003fd00000000000003ff000000000000040100000000000007ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-conj-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-real-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-imag-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "id": "exceptional-isfinite-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000101010101010101010101010000" + } + }, + { + "id": "exceptional-isinf-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010000000000000000000000000100" + } + }, + { + "id": "exceptional-isnan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000001" + } + }, + { + "id": "exceptional-signbit-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010101010101000000000000000000" + } + }, + { + "id": "exceptional-fabs-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff00000000000003fe000000000000000000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-absolute-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff00000000000003fe000000000000000000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-abs-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff00000000000003fe000000000000000000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-ln-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c0874385446d71c3c086232bdd7abcd2bfe62e42fefa39ef00000000000000003fe62e42fefa39ef40862e42fefa39ef7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-acos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000400921fb54442d184000c152382d73663ff921fb54442d183ff921fb54442d183ff921fb54442d183ff921fb54442d183ff0c152382d736500000000000000007ff80000000000007ff80000000000007ff8000000000000fff8000000000000" + } + }, + { + "id": "exceptional-asin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff8000000000000fff8000000000000fff8000000000000bff921fb54442d18bfe0c152382d736580000000000000000000000000000000000000000000000100100000000000003fe0c152382d73653ff921fb54442d187ff80000000000007ff80000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-atan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff921fb54442d18bff921fb54442d18bff1b6e192ebbe45bfe921fb54442d18bfddac670561bb5080000000000000000000000000000000000000000000000100100000000000003fddac670561bb503fe921fb54442d183ff1b6e192ebbe453ff921fb54442d183ff921fb54442d187ff8000000000000" + } + }, + { + "id": "exceptional-acosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff800000000000000000000000000003ff5124271980434408633ce8fb9f87d7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-asinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000c08633ce8fb9f87dbff719218313d087bfec34366179d427bfdecc2caec5160a80000000000000000000000000000000000000000000000100100000000000003fdecc2caec5160a3fec34366179d4273ff719218313d087408633ce8fb9f87d7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-atanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000fff0000000000000bfe193ea7aad030b80000000000000000000000000000000000000000000000100100000000000003fe193ea7aad030b7ff00000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-arccos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000400921fb54442d184000c152382d73663ff921fb54442d183ff921fb54442d183ff921fb54442d183ff921fb54442d183ff0c152382d736500000000000000007ff80000000000007ff80000000000007ff8000000000000fff8000000000000" + } + }, + { + "id": "exceptional-arcsin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff8000000000000fff8000000000000fff8000000000000bff921fb54442d18bfe0c152382d736580000000000000000000000000000000000000000000000100100000000000003fe0c152382d73653ff921fb54442d187ff80000000000007ff80000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-arctan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff921fb54442d18bff921fb54442d18bff1b6e192ebbe45bfe921fb54442d18bfddac670561bb5080000000000000000000000000000000000000000000000100100000000000003fddac670561bb503fe921fb54442d183ff1b6e192ebbe453ff921fb54442d183ff921fb54442d187ff8000000000000" + } + }, + { + "id": "exceptional-arccosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff800000000000000000000000000003ff5124271980434408633ce8fb9f87d7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-arcsinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000c08633ce8fb9f87dbff719218313d087bfec34366179d427bfdecc2caec5160a80000000000000000000000000000000000000000000000100100000000000003fdecc2caec5160a3fec34366179d4273ff719218313d087408633ce8fb9f87d7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-arctanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000fff0000000000000bfe193ea7aad030b80000000000000000000000000000000000000000000000100100000000000003fe193ea7aad030b7ff00000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-minimum-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000008000000000000000000000000000000100000000000000013fe0000000000000bff00000000000004000000000000000ffefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-maximum-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000000000000000000000000000000000000040000000000000008000000000000000000000000000000000000000000000000010000000000000001000000000000040000000000000003ff00000000000007ff00000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-fmin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000008000000000000000000000000000000100000000000000013fe0000000000000bff00000000000004000000000000000ffefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-fmax-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff00000000000000000000000000000000000000000000040000000000000008000000000000000000000000000000000000000000000000010000000000000001000000000000040000000000000003ff00000000000007ff00000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-hypot-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000004001e3779b97f4a83fe0000000000000000000000000000000000000000000000010000000000000001000000000000040007e0f66afed073ff6a09e667f3bcd7ff00000000000007ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-copysign-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff0000000000000bfe000000000000000000000000000008000000000000000000000000000000100100000000000003fe0000000000000bff00000000000004000000000000000ffefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-nextafter-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000ffeffffffffffffebfffffffffffffffbfefffffffffffffbfdfffffffffffff000000000000000080000000000000000000000000000002000fffffffffffff3fe00000000000013fefffffffffffff40000000000000017feffffffffffffe7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-logaddexp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003fc03f2d54301d4940006381c3f0115c3fde5746fdb5c0643fe62e42fefa39ef3fe62e42fefa39ef3fe62e42fefa39ef3fe62e42fefa39ef40019c7e908f54213ff207e5aa8603a97ff00000000000007fefffffffffffff7ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-fmod-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000bff00000000000007ff80000000000007ff80000000000007ff8000000000000000000000000000100000000000000003fe00000000000000000000000000000400000000000000000000000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-remainder-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000003ff00000000000007ff80000000000007ff80000000000007ff8000000000000000000000000000100000000000000003fe00000000000008000000000000000400000000000000080000000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "exceptional-power-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003fd00000000000003ff00000000000007ff000000000000000000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-ldexp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 180, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000fff0000000000000bff0000000000000bff0000000000000bff000000000000080000000000000000000000000000000000000000000000000080000000000003ff00000000000007ff00000000000007ff00000000000007ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "exceptional-atan2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bff921fb54442d18bff921fb54442d18bfddac670561bb4fbff921fb54442d188000000000000000400921fb54442d183cb00000000000003ff921fb54442d173fcf5b75f92c80dd4002d97c7f3321d200000000000000004002d97c7f3321d23fe921fb54442d187ff8000000000000" + } + }, + { + "id": "exceptional-arctan2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bff921fb54442d18bff921fb54442d18bfddac670561bb4fbff921fb54442d188000000000000000400921fb54442d183cb00000000000003ff921fb54442d173fcf5b75f92c80dd4002d97c7f3321d200000000000000004002d97c7f3321d23fe921fb54442d187ff8000000000000" + } + }, + { + "id": "exceptional-pow-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003fd00000000000003ff00000000000007ff000000000000000000000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "ties-rint-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 64, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c010000000000000c000000000000000c00000000000000080000000000000000000000000000000400000000000000040000000000000004010000000000000" + } + }, + { + "id": "ties-round-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 64, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c010000000000000c000000000000000c00000000000000080000000000000000000000000000000400000000000000040000000000000004010000000000000" + } + }, + { + "id": "extension-erf-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fd1af54e232d6083fe0a7ef5c18edd23feaf767a741088a3fefd9ae142795e3" + } + }, + { + "id": "extension-exceptional-erf-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bfefd9ae142795e3bfeaf767a741088abfe0a7ef5c18edd280000000000000000000000000000000000000000000000100120dd750429b6d3fe0a7ef5c18edd23feaf767a741088a3fefd9ae142795e33ff00000000000003ff00000000000007ff8000000000000" + } + }, + { + "id": "extension-erfc-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe728558ee694fc3fdeb02147ce245c3fc4226162fbddd63f7328f5ec350e65" + } + }, + { + "id": "extension-exceptional-erfc-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "400000000000000040000000000000003fffecd70a13caf23ffd7bb3d3a084453ff853f7ae0c76e93ff00000000000003ff00000000000003ff00000000000003ff00000000000003fdeb02147ce245c3fc4226162fbddd63f7328f5ec350e65000000000000000000000000000000007ff8000000000000" + } + }, + { + "id": "extension-lgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3ff49bbd81c16efb3fe250d048e7a1bc00000000000000000000000000000000" + } + }, + { + "id": "extension-exceptional-lgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007ff00000000000007ff00000000000007ff00000000000003ff43f89a3f0edd67ff00000000000007ff000000000000040874385446d71c34086232bdd7abcd23fe250d048e7a1bc000000000000000000000000000000007ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "extension-tgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "400d013fc47eeeea3ffc5bf891b4ef6b3ff00000000000003ff0000000000000" + } + }, + { + "id": "extension-exceptional-tgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff8000000000000c00c5bf891b4ef6afff00000000000007ff00000000000007ff00000000000007fd00000000000003ffc5bf891b4ef6b3ff00000000000003ff00000000000007ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "extension-exp10-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3ffc73d51c54470e40094c583ada5b5340240000000000004059000000000000" + } + }, + { + "id": "extension-exceptional-exp10-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003f847ae147ae147b3fb999999999999a3fd43d136248490f3ff00000000000003ff00000000000003ff00000000000003ff000000000000040094c583ada5b53402400000000000040590000000000007ff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "extension-sinpi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe6a09e667f3bcc3ff000000000000000000000000000000000000000000000" + } + }, + { + "id": "extension-exceptional-sinpi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000800000000000000080000000000000008000000000000000bff0000000000000800000000000000000000000000000000000000000000003002921fb54442d183ff00000000000000000000000000000000000000000000000000000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "extension-cospi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe6a09e667f3bcd0000000000000000bff00000000000003ff0000000000000" + } + }, + { + "id": "extension-exceptional-cospi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 120, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003ff00000000000003ff0000000000000bff000000000000000000000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000000000000000000000bff00000000000003ff00000000000003ff00000000000007ff80000000000007ff8000000000000" + } + }, + { + "id": "extension-fdim-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 64, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "extension-exceptional-fdim-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 240, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000fffffffffffff0000000000000000400000000000000000000000000000007ff000000000000000000000000000007ff8000000000000" + } + }, + { + "id": "extension-fma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 96, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "bfe8000000000000bfe000000000000000000000000000003ff0000000000000" + } + }, + { + "id": "extension-exceptional-fma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 360, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ff0000000000000bff00000000000007ff0000000000000fff00000000000007ff00000000000007ff8000000000000" + } + }, + { + "id": "extension-fac-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000060000000000000018" + } + }, + { + "id": "extension-ncr-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 64, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + } + }, + { + "id": "extension-npr-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 64, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + } + }, + { + "id": "extension-e-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b1457694005bf0a8b1457694005bf0a8b145769" + } + }, + { + "id": "extension-pi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 32, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18400921fb54442d18400921fb54442d18" + } + }, + { + "id": "extension-domain-fac", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 24, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "extension-float-reject-fac", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "extension-domain-ncr", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "extension-float-reject-ncr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "extension-domain-npr", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 48, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "extension-float-reject-npr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "where-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 27, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000080000000" + } + }, + { + "id": "where-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 51, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000008000000000000000" + } + }, + { + "id": "status-invalid", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000" + } + }, + { + "id": "status-divide", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000" + } + }, + { + "id": "status-overflow", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "7ff0000000000000" + } + }, + { + "id": "status-underflow", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000" + } + }, + { + "id": "status-clear", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 8, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "4000000000000000" + } + }, + { + "id": "status-lazy-where", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 16, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000004000000000000000" + } + }, + { + "id": "arity-reject-sin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-cos", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-tan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-sinh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-cosh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-tanh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-sqrt", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-cbrt", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-exp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-exp2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-expm1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-log", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-log2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-log10", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-log1p", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-ceil", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-floor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-trunc", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-rint", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-round", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-sign", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-square", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-conj", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-real", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-imag", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-isfinite", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-isinf", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-isnan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-signbit", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-fabs", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-absolute", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-abs", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-ln", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-acos", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-asin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-atan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-acosh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-asinh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-atanh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-arccos", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-arcsin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-arctan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-arccosh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-arcsinh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-arctanh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-minimum", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-maximum", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-fmin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-fmax", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-hypot", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-copysign", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-nextafter", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-logaddexp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-fmod", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-remainder", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-power", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-ldexp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-atan2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-arctan2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-pow", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-erf", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-erfc", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-lgamma", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-tgamma", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-exp10", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-sinpi", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-cospi", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-fdim", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-fma", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-fac", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-ncr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-npr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-e", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-pi", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "arity-reject-where", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "spelling-reject-float-power", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "spelling-reject-logaddexp2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "spelling-reject-heaviside", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "spelling-reject-spacing", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "spelling-reject-frexp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "spelling-reject-modf", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 0, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [] + }, + { + "id": "certified-sqrt-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40105d8e3ff2010b3ecf06eb402b212f3ff09d163fe26b5240052a793fc89d8940094087402a03843fd056e640081a6f4011d2013f527df7402d1e95401dc1023ee6007b3f77ac403f56292b3fcc07a13fd0fb0340209ffd3f96db6140208f4d4006bada4007ec5f3faeabf0403007b5401c56354000d47540022247401acaf5" + } + }, + { + "id": "certified-exp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f813d1b3f8724c5400a58663efbef813f021fd23f8bff413fd7959b3fd3a1073f31e89b3f949bd43ffad1273fbdc30c3f990fb83fb445c63fdbfc353f0b765e3fe8b0683ff53f703fdd4cbf3f4684193f9764853f07d5803f628dd73f9e3c783f629c443fc238073fbeffb93f29bcba3f80e7873f0ca8073fc19f063fb29f08" + } + }, + { + "id": "certified-expm1-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "be99f8f43f4b334ebf0b574c3eaf7a75bf0b8cf6befbbd9cbf05a2c5be9022ae3eee010bbeff6c3a3f6d3fba3f903ffd3e82c68bbe8d6c773f8d6a963f36f312bef50acdbe3b52e03f176d523f76d5a23f15f6843e0e132dbe95f42b3f512cdd3ed1ae9bbecaecf13f8c7b4abe2378ca3e5780633e1b9c663e32de9e3f16c859" + } + }, + { + "id": "certified-log-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fafe8f73ff051663fe8309c3f9c33913fa598c43f6f69533fd0c91e3fefd8e83fcca67c3f95f94f3f0cd4e64001742f3e0a2e773f40a9e5be92c2603fd1d8c73febe7663f5806323fad18363f94eaf23fe3f8513fcf36633febb32f3ff32fa43f9828023fc67ff13ff003183ea6670f3fdf163e3fe3b66f3ebe29e2bfa442fa" + } + }, + { + "id": "certified-log10-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f08c0d63f4acee6bf1f75c83f46cce8bd2c6ac93f38283c3f2ab4dc3f21116f3f0ab6c43f44775d3f1a04403f3769133f567652bf1f26aa3e4fa7463deb93b73f6097b53ea1f5243e28fe833f3cbbee3e66b61c3f3ae929bf09f95f3ed428cb3f5f70d73f65912a3f47a33d3cc44de43f33cc2e3f57eb023f50d38b3f3e5993" + } + }, + { + "id": "certified-log1p-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bec18fd5be23a284bf8db1b33eac6b8c3eace35f3ef04f89bc50e3e9bee7d0843e48c7d73f0b614ebfc75e6abf429ca43de9c11a3d617799bd7b0ade3dd410a9bfb47cf3be9bb5923ea9cd773f04c2e6bf280d26bf57e827be1c0b913ecfe6abbe7170e63d5195f43e3231d1be2c1ff6bd92560ebfb68558bd5aed57bed5785b" + } + }, + { + "id": "certified-sin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e90b434bd93cbad3e745e673a8e77e3bea240cc3effe444bee149fbbeb64be53c8a0b30bf0abcbabe6fe597bf1b47bb3ed2427dbf33ad98bf27578fbec8fcdfbb8b6562bf189be33ea17b4e3e5652be3e8a85acbd45b842bf1e487b3ec9e6c6bda90f2fbf292d0c3eae305c3eb898643f051468bf04cf77bf14b4febf03c68b" + } + }, + { + "id": "certified-cos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f7ffc033f549cb03f36b8743f4a6b463f78c57f3f7f3b753f758c0d3f6469513f7cb6903f76d5893f78af4f3f7ae0ab3f7a31a73f7ffa373f64356c3f7b94d63f775ff03f7d1cc63f6686d63f55e1c93f7ebde53f6963293f731fc63f5e5a1d3f62cd723f61fbb93f5e56973f7a4b6f3f5a452c3f7ef69a3f7eaa013f3b994c" + } + }, + { + "id": "certified-tan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf30792c3f65c7803edf6621bf8355d03e9afa1dbf791bce3edc2a0a3e2f94c43d5873113e1f804abe5a0dc2bf3193dc3e98c6c2bf4ca6583f82324bbb8a28ef3f275a773f4326f13e31309e3f0c324bbf6de3d03f0ca5193ebb7082be805cea3e852f92bf1312e1bf7ad958bdc0b60cbe93b2f1bf4750b6bf468002bf465ec5" + } + }, + { + "id": "certified-asin-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf57cf763f16650f3e9c1ac03ed0a6d23e9b73f3bf54dda4be4407c9bd14b5d8be762717bedafdaabdd008d0bf1d0c2d3e164435be8fe9773dfc59ecbe1f07ce3f64240b3e95412fbf36d9df3f16a82a3f157edc3f2e35613e55b1163e6949163e9751483e6c99f73f0e7ef9be759bd8beba52e93e611600bef00540bf177f14" + } + }, + { + "id": "certified-acos-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fd864ad3f5e6b673fa71a313fd0fa073fcbc77b3f6e78143ff7690f3f5ad1683f9bc89c3f9d0b523fbe26424014a2a43f6f65e74005c02e3fab4fbb3fd4e6e63fa3d8ca3f414538401f2a223f3a9d423f4c17e33f70ef8b3f8d22be3fa64f993f9981b63fbd09303fd54980401afacd3fe8cbbe3f91903f3f5182923fb0a6f8" + } + }, + { + "id": "certified-atan-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf2c528c3e9d6ce63f02d22abe03a07c3f1783233ec846ba3f19d5fd3eca6df7be5fc6f63f110bdbbf229731bea656e83d8d290e3ee2c7e7bc47f180bedb39583f0d01e23ddd9ba6bf066206bf2980dcbe02e65abe82f820becd09d2be4e8b80beb3cad03e99a332bf12aba73eaf3775be5f93f83e2acf9dbe002c343ef5e556" + } + }, + { + "id": "certified-sinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f5e67963ec641a43f36285bbefde3f43ee8406e3e74d40f3f0af65abf4f1bc73f526aa0be2e41183f624160becbfaaebe5159273f446ed33e77910a3f1601d13e50d35dbf2d092f3ef6de40be84aea03dd3a80a3f14dd47bf547d9c3e53e7f53db02e5f3e247052bf5c04bbbf197828bf08250fbf305c0bbf24ff733ee7c75c" + } + }, + { + "id": "certified-cosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f850fee3f847be43f875e3e3f8159d33f97e6383fa6528c3f88ba3b3f825e883f9893bb3f807f8d3f84d87b3f815ec63fa726473f900dbc3f80ea4e3f8aea283f9004683f83ccb83f8499203f9ad3673f80f49d3f8066df3f9750c23f8505063fa6070c3f96ba803f9e098f3f81af843f8029073f8dbdf13f80f7953f80577a" + } + }, + { + "id": "certified-tanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e61ef53beb515ee3e3e0d81bed252c53ef504753e0e8383bf0396abbf1668603eb280033f1406413f03d769bee9ae563ea7721b3e5a6419be54f5663d8c83573eddf2053f276c54beda11d3bf219dbb3dfd0be1be914fcc3ec970a3bef5845dbf2218f53eef8b633f18275bbd4593fbbe8110533ed690fcbf24e159bf019fef" + } + }, + { + "id": "certified-asinh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "be9b06b1bef70d09be968df83e9367ed3f212b50be8ed979b981e86ebe8b485cbedb1637becce82ebf0137bf3eb576133f1dfa6dbf06fd35be7ba7133ed7c179bdef7f113db56790be14b300bedea40ebe244b6bbed0b831be9620a03e8fa4dbbf17a1813f3866c4bf005be6bea358ecbeaa1f6dbe457a733ec121583e81dc52" + } + }, + { + "id": "certified-acosh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "401a177d4024e7354023e0cc40036ad03f982fe14008133a3ffcd4773ffe9df03fc93bca3f7b0d013fccdc4b3fc3048b3fd1d2453fa0bce53ed4bdb83fbded193fe6639740236d773fb4063e3fd8616d400ceae73fa7414e401a6a9c401577bd40279a9d3fcc276b3ff8706d3fafb6c040224e313ec2598c40231b8a400ad9a6" + } + }, + { + "id": "certified-atanh-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e8632dbbe22c68d3ef507d3bf2b250d3ed9a0a73e6a4923bf7ac3c53e375387bd614dea3ebcdfe53e8d8f39bdbbd68dbee6c7793f39bf903f1f138d3d013735bd1c33e8beb4d316bf86c132bf822bf13e48a0343ee52d85bf2681923f5505b03f4738043edddf963e2ccd813f155747bf524b85bed4bec73f1c2adfbec9421d" + } + }, + { + "id": "certified-erf-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf0481ee3f35d43d3db7b4353f08ffedbec9f49a3f0d8e8d3edb1f043f3516563de04e4dbf37abf23f3df04b3e1a4cc23ea96917bee4b4683babff19bf09b686be7d2dd6bec00a8ebee892063efb4f063f0e5e073f3b055ebec53f993e3f0f9b3f3149b63dd54fbabeeb0d3d3f276090be309378be6fe1933f1ae877bf243d28" + } + }, + { + "id": "certified-erfc-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f3a00b83edbb9613fae6a543fbf4cd13f1426ef3f9dfc7e3f88e5b83f74b6583f60dc213f6380c43ea1734e3fd9323a3f6b053e3ead882c3f169dc63f21f8583f912fd03fbfeeae3fb5fe003fa61d9d3f1534933fdd6e283f8cd1ce3f955c323e914fa23fa74f383ee06dcb3f146ee03fb401503ef744c53f5b0c993fc28ab9" + } + }, + { + "id": "certified-sinpi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f44d2a2bf67b1083f29c6c9bf6282b8bf7dc236bf7ef96d3ed93ff1bf3792cdbee57bb4bf7ed6ea3e6985913f11af743f5379d2bf66ad293ec23b573f5751713f1ec5363f78c2cb3f754e1ebf586036bf12f3e23f451781bf7856fe3f35d6733f5434813f08f5dbbf55a835bf7dee8ebf273d463f7fc0643f42a7943f78ead0" + } + }, + { + "id": "certified-cospi-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e9c8c0cbe4d19ae3f778d8c3f4d93833f6bc1f1be5ebe87be07aa643ec95cfbbe9d0ef23f65ec413f30f05e3f36e9e83eeb69293f7fb5553f719ebbbf065be1bde9b67fbeb5c0653e3c8bd7bf1492a4bec8c5b43ed65d683f5418e6be6b979d3f750f8bbedb1f90bf2503ce3f72f63f3ead62163e35305dbd74f210bf425070" + } + }, + { + "id": "certified-exp2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f993ed43f1e63e93f21ce3c3fdc0c183f17c5033f5ff2333f9782de3fab9aef3fd878773f6b98893f7cc71d3f32587e3f581f0c3f5613a63f615cf03fa547363faf26f53fcbf4933f847a913fd919843faa474c3f1328413f9dea4f3f4bf0d83f870d1d3fbcc4713f6c28fd3faff87e3fb3e2133fba420c3f975eb33f9034b7" + } + }, + { + "id": "certified-exp10-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e5cca2f3f1dc935406d14363f000b3b40c8fb9e3e2ead5c3e49fb6a3ea0f4113fa72d233e6369dc3e96418d3f1cd5733ff79dcd40a842b43f2196453fbc911440113d4a406fdfcf3e43aa193f4e57fe409516d53e89a906409953813f7b399f3f6cfe393e87b3793e2859da401d521c3ee799c23e3823e83ec17816407646a7" + } + }, + { + "id": "certified-log2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40285017bf0d0acb4034f09d402369d73fe2ac103f06a682401d431a40067a4c4014d7e6beb430f7403177903fd607f340144756402f1afc40183fbb4023809e3fd0073e3f6061a23f047c54403cd7143f2042d33f2785033fec2170bec717773fdb10453ff69f8a3ff954fb403e39de3ff09122bf582e074024500abfd365d2" + } + }, + { + "id": "certified-cbrt-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf1a50aebf3f30bdbf3b696cbf4f80403f447bbebf661625be6f01043f2bb0203f4fa4393f680a1ebf482bc3bef443c5be864d4c3ecb2526bf62cbf8bf35de08bf1feda5bf536884bf222f8ebf51df5a3f6c3ba8bf6d0993bf2cf6643f4f32f0bf4ec8353f66610dbf286d53bf4f03df3f462ae13f6823f3bf046a873e9c06e5" + } + }, + { + "id": "certified-lgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "405195ff404e573c3fa2166140b9658abc81d4684105e9414064196740768a713f80c67540c4b30c40eb493ebdebfc9340a07de940cacb443fcdeb503f9e1b9e3f63661240af7d69400dad203f96792abdf8cd21410259f940f5b4db4025b71bbded74833c27b0fc402ea56f40ee5eac3e25b85a3fd9038e3d820a313ff0ddc9" + } + }, + { + "id": "certified-tgamma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 128, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "4481d56e41bb56283f67f9b243d99468411f928e4095a5bc408195c7412edc6344ec102c41ca2e2a426996ce3f7daec2421be1af42beb0da40841a8442c4c01f41d24f9b445fde7a44610723402d598242efcf234048675d4273b12d4312ea89458674664215f82140d1777a402af16a40385ffc437cdbc83f64bfaa3f69efb4" + } + }, + { + "id": "certified-hypot-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40843bab40ca83cc407bc72d4076ada23e84650d40879d063f8ff1ec4091f9b640de2dfd40c58bde40b9130940a285f640dfe1c44082ea4b4083e1023feae4a840111eb04053289740e78e87404a6b12409f0bbf3fd3789740df201040a8426f4006f0904021a315400113f940e867c73f42ea393f5cf8da3fef896d407d0411" + } + }, + { + "id": "certified-atan2-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "be8590e4bded1ffd3daa93ea3d4be5ebbeb8aca8be693288bd8083003de40e013dbb097c3f1aea43bd0ea23fbdac6ca73dd733933d1be51ebb1f85d9bd56e947bd47a1613e2924743dab71a1bcabbbc8bd3d016e3dced4373ee94bf2bbfba658bca54aec3ce1a724bf1ab09e3a7cd97cbe67d01f3d342a36bd1b663fbdb66c4d" + } + }, + { + "id": "certified-logaddexp-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40f8c9e63fb8ae2e40456765407b59fc40eb52c640e3b3e940c261f940f0da7840055d98409eccc04095d07040da7a4b40f5ca44406fd07341004f1140d7bebc40f3554740e8dafe4055e03640f594cb40f35f944048ee1a40afebd740e5fbc240d9db2a4106f1194053c3b640d01e174064afd140ba4a8b3f62e44f40f6fdaa" + } + }, + { + "id": "certified-fma-float32", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 384, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "400e6b73c07aeaeebe95c3ff3fa60e26c06006503fcd0f8fbf6b0a0d3f9db340409b1b6ebfb86cecc0920af5c0b2bb44c0110ababec3a464403c5ee8bfaaf170c0305e573f000441bf509ca0c098de0a401c05004004ac56bf96e38ebea14e4ac09987e1beb4c83bbecf9c83bf935e9cbe72b635bfeb93913fb0b9d23f72011c" + } + }, + { + "id": "certified-sqrt-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40003be8662a5fb43ff17d28dc1939d73fe623ff8594f5134005f50bdba3cfa540022734b7acbe413fe5dab668b3126a3ff8830c80c000c040047d7528c7308c4000a5a085a5fb6f4003aa06c7aa116b3ffb8df4e0636edf400461bc406b5b363ff433e1a470ddd33fffd91365146a303feef157252cefb23ff69d2c9bd4e8b04003d54ef6f2cc214002b56471febdfa3ff8c777799bd1bd3ffa5d1df156e0c74003b8210119791d3ff75d4ca9afac9b400553f493d117e84001a2b63ee8e1304002f7e74f1b86423ff94ecafd04225b40020f39e7bb6d354003e2f7546ef0b93fe795aa4a607a703ff75fec854d201840063eb18a3c0e433ff5d9e8925f837c" + } + }, + { + "id": "certified-exp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe8cf9f96d70f593fde973644f9fe663fe22892e4bd6fc83fde2afb2405f5ca3ff4f3ad24acf3543ff276fc441d4c7e3ff85b2c3a62884a3feb1d51a7be45183fe0580d424f06d03fe2856852b6b2cd3ffc56e39ce7883b3ff4e7d08112b6323fe180894c24ec303fe24ba3156c25403fea5c9f5478a61c3ff3fb0072939be53ffbac769a77e3c63fdd6bdb37e5f93b3fe21f21ef5347f13fe8316adbad314a3fe6287f6861891240013928063665063ffc58e0be6f4dcf3ff9d3d50b310ddc3ff1aac8b1af41583fdf70d2db4edc263ffbc07c126f951e400107d1869c407f3ff483a8ce871ec53fe14ee49e5fc72e3ff2e0c8c04ac3cc3ff56f7c46e28ebc" + } + }, + { + "id": "certified-expm1-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe9994f99c2353d3fe0f0dd923a55c23ff0ff0acbbbdde43fd6ce5ec8f5a963bfd3ee3010b035433fe4d1b06cf9a6b9bfd7a42be64b6b2fbfc35e481f8c8c983fdf05ecaf28cd293fc9c3121379f2df3ff199b6b52859223fc1007234619bda3fdc8d4918a2b58b3ff12e4c166a19063fc9551cc084b1153fe794bae832df62bfd1f36036d8c761bfe16d612e0b56eebfb59b8e79fa3f573fd60de7116536a8bfe0276d018418023fc3007f6f9e1eb6bfc53c8b9bcb70bbbfce7a377a90754c3fd9db676c58b1fcbfd5c651af351a4ebfde5c9d5569fe61bfdf5cd019caaa56bfdf6ebcefe3569c3fa00d1d7526dc44bfd1f9ab36007df8bf7a57d512bdefd5" + } + }, + { + "id": "certified-log-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffbfdba27e447593ff3b55a0f5454153fff592f8c5ba6b53ffcf225e992e8273ffa320b51a1a8cd3ffa319b87b6396b40005046b8575b764000159cf0870b7dc0013c869a3ce87d3ff643b42dbf22d3400090ed49d4c7233ff208ea175be4e33fe6389c0dc8ccb9bfe5cefd96631f053ff9533cd948d2cf3ff3827c220bc4333fb3c2c074d326e93fd349eb0c10fc893ff53c0c5f54b4af3ffe1549a786d979bfe16a78239041763ffd3a0d5b12531c3ff4b556378365453ff97930157530a93ff7ee65ad2306eb3ff874f431d61d773ff22cd5bb5d03dd3ff15a62aa91d2d83ff537ecd46687053fddf8e68cd2f7a63feedc8fea7679ec3ff884ddcb1ba4a9" + } + }, + { + "id": "certified-log10-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe758a636fe51e73fe5002664c1db7f3fece4c1c8b1d4a33feade0934d8c1ed3fe41f1044d168553fd0aa1642ea02623fe0aa839c8cb9693fe6a48e374c63693fe4c5531621d8183fd4f853951fde483fe623f9b0290cfe3fd8a019b3d537083fb1a7987ccf6f9d3febe97e41dcbc8c3fe298b3bf9545643fe4960c8c2fc32c3fe82e1df671dfa93fe60d9f6a208e7d3fc61053c258b7f93fe68ddf0bfc706c3fd70e04133f25493fe31b1462690adc3fec139cbc73a2aa3fe9cd9f705cfa683fec1a84550ef3873fec4180205cb59c3fd9d8c6e2afdcb43fec455099710ba43fce6ce02ea308463fea8817fc28b2b5bfd3b93549806d513fdb2774a4544804" + } + }, + { + "id": "certified-log1p-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfc1e43d085cb220bff13126bea0a058bfaff5c51259f2493fddf06fbac80775bfe9fd5d586aa21fbfc4e81a78f39a3dbfedcdb22b08e4153fd47d4aed5dbf5a3f93f360310ae91e3fadf3db18443cc03fae723753b0ff01bfee8d2f0bdfe0c33fd71745a00d8fcfbfed4f9c20edf5403fc59e24761b9d73bfb444cefe38a0d9bff03696740d7437bff8c0d16edfdfb43fc5dbfcde040cb53fd43d31524b5f74bf742f939938c3c73fd39cf310c8f106bfbd8d5a8e30f6593fe1b8406a2e69413fbea632ede9ca833fe1f038a8ee9d81bfea7403198a5e67bfd9a31cb26494e23f92b7abb69900d0bfe710ab762b4596bff512711a21f5813fdf55b3093c2b57" + } + }, + { + "id": "certified-sin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfd647eab328f2ecbfe6291ae1148e213fe1a935f0b136a13fd7395ed31883f2bfdd4c30aefa15f83fd18b3b83f4ee9abfe0ea4d243841083fc65359928d381c3fe0775a321b6625bfe16fabcb340447bfc9f585059082f5bfd48a739e28ad193fe67824a911a33abfe2f08f76520d683fd480b6f8de53d53fc50739e7392bcc3fe2187a52fd65e93fd8fc770f947e4c3fb83164779f5b273fdf9fa6fc91e5933fe1bae938ef4e31bfd709a0d77e44163fcbe6e3f98944333fe4e22af1f74dfbbfe361d961d2b456bfd2c5038afd99213f966d5f53d18531bfdad2d4a1ae6425bfda0b58126e6e823fd556e30c7a50b1bfe48c22be57217f3fc9654224c13bdd" + } + }, + { + "id": "certified-cos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fec927e8d46bd4b3fe8cf43dedb55613fedcd55b454550b3fed448cabf4b6ca3feeb77e3de6f2f23fe946cad1c8d39b3fe99307eb9a2e593febc9455c4b8fd63fecc39afe638a0a3fee67362375dd503feb75d227f50f123fe89917254c41f53fefe6644a10bcd63fee1243c57839783fe668f376c1364a3fee1d1a98482dab3fee9fa15fb834293fefa3af114ce1153fe9b9c72c65eef33fea18fe77eec69c3fef24afa878db383feff53821de16ff3fe83fab5ac1eb383fecbd9be970c7fa3fee2a8f36ed48443feb8e6f2f4a57933fec9dcc5b9693533fe7edc621a534c13febe5867a0d93873feea1f95b38e9843fe9b8a67f0593403fec0670b4fa43b7" + } + }, + { + "id": "certified-tan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fbc22a4754c7723bfbb2ff162f7e1ef3fe484c5c4e68cd73fea6066615a78bdbfd9e3fa24aa753c3fb6e718eba13806bfd585aba0dfae343fd13e1b2e534f55bfa0135db053c7023fe0a0d0009ed35fbfe065a708874beebfe9cba2fd5cdb093fe2bcaace7746703fefd6ff78539a75bfd6860f77880102bfe9d755ac77151dbfe14d5596872181bfc198e97bdb60a8bfb3609f435fbc943fb547c23964e4d53fe8e026bf1d6baabfb1eb131a7c1725bfd2568d655e7e673fed17dc7dcd2d003fd8d1e28a25cd9d3fa175cf4d0c4df23fc99e524e62d1b4bfe6be39de491c91bf9d1021a344d8263fe2a944f2b2666b3fa57208eca541be3fe4f5a32f3b728a" + } + }, + { + "id": "certified-asin-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfcdeb737886df7cbf9434bbf155299dbfe2fcea06d87a563fe47b43fcb8e7b7bfd011a1ac1e625ebfe9b5cc70cfda7b3feb7443f209d02b3fb0f59c9ec64c7dbfc76a64cb137fbe3fc5381e282159b33fe060da87699f16bfdbb2be92b1639a3fc6209ee8a8a359bfe51aa1f65f15783fc78a781c3ef0b23fdba292a63cfa103fecb94afb688c943fca99248f69e8963fdcb9b265b58f283fe7843bb68b87be3fd31c108a3e41a4bfaf9e98188d767e3fdf57358add1820bfe1342170e2359fbfeb0ff5e6a12c24bfea38afd6a059673fd96b816b476f4ebfcd5eef3f467f883fc09f78ffdeb96f3fc743ed75b60db9bfe1363cece4c6c33fe6c732e77052ef" + } + }, + { + "id": "certified-acos-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffdc2a1ed76f657400334e7afc7ae463ff79306871934fc3ff943a498efca6b3ffceb7ca092e14b3feddddc9479606d3ffde1e9cdee834e400299b061ba22863ffdb7a505867eaf3ffbae7e2e40adf240016c58bf14b4543ffb8ccd9dfb47c23ffef52dca78d2c63ff8daa82cd429323ff0187c8e68517e3ff85a159b504c103ff7811950f6916c400033681307d76f4001650312a79e483fe9e78ac0f0f0cc3ffd1152fbbc4b163fed69ee8c1457c13ffd472197c58e163ff930bea2f4d8083ffceee4eacdec603ff91ff75763de3f3ff72e2da6dc056d3fe931936832a186400231162bfd22c73ff5edf113eb21d23ff4610df319313a3fffdab65eb33a0b" + } + }, + { + "id": "certified-atan-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfdd863c3d652057bfe0816ba8cb539fbfe3ad7933637c1b3f9216bdb63a4110bfce42afb42d17223fd65cdb57e9ef5ebf79138d3bb8b8e8bfc5aba918ec311e3fcece03fb099fff3fc13edee8b3e80dbfde36fe8ca5ed47bfdc4106022d18523f9e20697262be1ebfb882ab90ebc5123fe1b23502609678bfd31be3f9deb599bfd20fed9f747fac3fdc8ffeba95b8213fe2df04b3457a57bfa0d232e7ce3d46bfcaebc219a9eb473fb989ab8f0c605cbfe28c9f0564930f3fd0fd3c916d79fdbfdad8c22ff506f13fceb1d7cdb7210bbfe4b91727e8fbd3bfe2359994863420bfbbdb0c5729803d3fc5b1180a2e0aed3fdcc20b75dc7b2a3fa1c1ec12adafeb" + } + }, + { + "id": "certified-sinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fd19901c946010bbfd919a26f4012ee3fe77c4966e838843fe3f9cff6a25a60bfd314cc38e45b47bf90c4798ddc6765bfd298142c317d2f3fd3d73b21e26a153fb2f45db0a03850bfd9f881142814ffbfe8c4ffac1ae37f3fdd3bb9738bde0b3fd27e36469fd39dbfd83e54f77d29893fe04be86700029a3fda58c1bbe7c4dc3fe6adc8b89e45253fe12c5d9b5770703fdf8fc172e0343e3fe53ced0d965f543fe55a935b0f47783fc278ec018e051e3fda5c92e11835c93fe04ae809f93975bfe0571dbe680e94bfc8d98b2aa135e73f84b26827e2f72d3fe97f1e5ccfb8f8bfe922fb6a6ddc073fdbf43cabf9f6c4bfc23a1d66e57d683fa16f93a5107320" + } + }, + { + "id": "certified-cosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000104974ad3ff13210db66d4cc3ff06ff09a981f1a3ff26784b5e8fe073ff53c169b64a4f73ff0c994f9a236cb3ff015656ceb44683ff54d2939c6181c3ff4d6af82cb62c93ff0aa57053a2a1b3ff53844d9f98cc73ff0fc725b643e9c3ff03496a3af4d563ff00229b76fe61b3ff22d35b1a6f6b03ff1c2f9e05a83513ff2949f0aea731f3ff33e2373e7a4c53ff13d63c11ee4f83ff000156d64ce3c3ff49f55c513efd73ff09f068bb8c6323ff32382bde5abf53ff08ecf02bd06c23ff029ab606955a73ff2ac8e32a430fc3ff284e70a6af2213ff3c3f3000596813ff0011ab5d3c2a73ff0721c4fd1664b3ff490148a2bd9903ff0df56f3dabeaf" + } + }, + { + "id": "certified-tanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfbee46032fe52773fd74e1af233c3d1bfddf718f5219c6c3fd91ac90f1935d7bfb4d65829a35a5cbfda4b83e7bf89233fe4dab1b34790593fdd6f8b6afecede3fe38a0aa112cc3ebfe34fbc988d59b7bfac2787891f65103fdc4e696100d9e9bfc8c9abb31b8e29bfd9b3a232017aa93fd343fadd7cf6793fdee904385cc1f83fdd214b34b35e92bfe2997dec11b6bebfc2d4520eee200ebfd4c2299e6710753fd7b75691eb781e3fe4f4bbd4d87858bfe2e3e4afaaa2843f7dfe963ad125ac3fe294717f500b23bfd40a063a3c15ed3fc31bdf754639a53fe12f2428857e2fbfe14bb86690b6c23fd666074260facfbfda0c3675ec1e62bfd29c4deaf85f05" + } + }, + { + "id": "certified-asinh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfbd5b8ff223eb51bfd337fdb364bdb13fdb4ef46374d476bfcada9ac78b85f33fe45a8b77c6151fbf785e4746f1bb75bfc63d341bc5c507bfe13c20959fd58c3fe366867168f59e3fe743c51d8a68ebbfe56c22cca534123fe0df9dd7cad652bfdba0741613dae23fc5dac93556d05abfe747a1942c59a5bfe25b465acc15d1bfd93601214bd4923fe12b26d8ad2d5abfe676c1277ceb793fdad985453f784e3fe0d4236e30ee3f3fe747f4579bc7233fdcf952239b20283fc2edb2836ea7a1bfe5bfd5bf1c797bbfe31455d60870e4bfe14f526aaa6c763fb2f2f9638a54793fb5d5fc414b90f33fc862a3bbc27b8e3fd09483edc9532a3fe14dd5a918344b" + } + }, + { + "id": "certified-acosh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe108a6b75517844004aabab23c133c4002c031bb5493803fd5364e30c4c35040049ee43f4963ee40020f5eda9b274240038517047c220a3ffde5873a7993aa4000ad6a99cb3c463ffb11590dce29b24002e9043bdfb3b24002d88c6bae7ec64002eb0defe4cad940041926694d64a24002c5f9ccd5d9623ffd253684fa8ea040047097138710b73ff39e9ab8989c5e4006050c707031464004c3102021eaf34000c8ebdfb31f8b400336136f0692bf400114520e1ddbd73ff7016eb7ea07ab40060ab1dafff62f4005c5bb216411644003354e66d05029400176395344c472400235b13a1b81723ffc0f415cd6a1e440031ff067f01a2d3fec7d0363f3cdbf" + } + }, + { + "id": "certified-atanh-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe0350dcbbd2f4ebfcb488839fa5fcd3fdcf12f3c8b29d1bfe7188d3ed13b9d3fbfb6dedc329b99bfbdae05a0ad2154bfa3203b10965771bfe19fa143dfd2a43fcdbf2d1b3ffab8bfe4328c11bb09713fbd43f7412d7b503fe8f90785109f8abfe10a8144dc3b7ebfe0839e1feb9a1cbfae42b740dea087bf83af8e02375c7c3fb5468f370352b3bfe49b8f309239db3fca7acdaac03c87bfeea3a963619c1c3fe2f306f85c6d16bf7628e971fb015abfd8a5046350ec72bfc7a0fdedf51de8bfba7ff42c3345a8bfd3904555d14de23fef6ff9f2f06efa3fdaefe527d990b53fdf8f5ca686ebf03fe8fc384b032ca2bfed2b6521fe1badbfd45961e61e7795" + } + }, + { + "id": "certified-erf-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfa5ed3b201e964d3fd3c600207a6e53bfb01bc434178b12bf9e5a98c565d19d3fe56750da2c74efbfda1c4ecc20f047bfb4c8726d4f2cc0bfde9fbdaeb47109bfd6f4ad2f537bf8bfc2cbd367b177d23fcf910ebf59bb6f3fb715414a9f4a1e3fd304d30ecb2daabfe63817610e3e843fe51fbfba6dc870bfdfa72d1fd5adf23fe4fec48063f6f8bfb8d42ab7abc5173fce5917af6536643f36dface3fa49babfa4c550012a6e79bfe3ee6a7650803c3fa4cf2ac187fc91bfe13a9f513203733fe78b8ec7356ef63fbb7ed121aec54f3fe5e1c7dbe2b37dbfc1ffb0f461e3d43fe04d26493232983fd4b5585f4228eebfdbde5e6d66692fbfe012885513e3fd" + } + }, + { + "id": "certified-erfc-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffba9c30d961d143ff60c839f7dba803ff4f55d2271a8c63fd6365ee8699b2b3fd863728ba2d9a63fd7d26807cee88a3fd2e260396fc8a53ff3eabdc7e0d5023fdfffddd340f2b13fd762d8feda5a3d3fe895a539a274933fd110e7a988148d3ffb11b6d1a427ad3ffa7e6a80a800b93ff567a86641154a3ff34ff8c8381e323ff4af35c8d358a93ff6fcb92751b5f23ff93b1e0935214c3ff6b034359d41e73fde8a45f67859753ff83b8e393f4d0d3ff971758a42579b3ff5d33e2ff371883fe12ec95e7ead053fdb2eddb75393863ff915df9e12f1903fe5ec27c3a584bc3fd2f6c6ed730a2c3fe44656344073443ff995a6ac0af7873fe0c1432b1a2465" + } + }, + { + "id": "certified-sinpi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfeff938701472ae3fe2e2e9f3f11e833febe1753ef3d7c63fe03a112106abd73fe35e49907032113fd4f79031660e02bfeab501e15b4162bfee34937a9566f8bfeabbf9c1ce1a86bfe80c68fbe54d0cbfeffb3a434aff113fefba89814f470abfedcf1d965c96c43fe6d607c4623692bfed3732794cdb67bfedf475dbbfab04bfeffb3f02c7f0303fe0cbdf8d5c42343fea98a23b0bbfdcbfe6e58da49347d1bfee19c9716d4b51bfee64bc8317b3523fe828c2a37176a3bfeffee75d2280a0bfefc8fe21a32c0ebfed4642dc6f3bd2bfd06b077db262db3fe3fc1b486ebc2c3fefd61fbdc00fadbfec2e05885d6efcbfed77293142bf923fee928244579119" + } + }, + { + "id": "certified-cospi-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fefa70dd5948ebc3fe3a726d3dadb773fe8ed4c466d9e163faab7dcaceb5a1abfd76625553b8d74bfd0ed208babf834bfd79923e3498e15bfc224c4bed2d2893fc9977f14c86b703fedd3c655ef24aa3fa7949b44f4ee403fefdf24f8a7c9163fc33e878c108d473feffe42e3ce3b133fe0a6c8644d71e6bfbe69c17675cb023fb173729518e024bfc10898c95080f53fd352dc6f3912d63fd21d64f21179973fb2d39f877b385bbf9abe29b571526bbfb7f6790e33f7efbfdd05c4d34fb088bfa2c57607c812d53fefa138219816be3fdbd8b289341e413fef795df9d9e15bbfe8d912ccb5c05c3fc5ac36e44951223fee107594b5bbc03fd79214bbbb7cf8" + } + }, + { + "id": "certified-exp2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffae27d2096a6c93fef2f5d3d84e50e3fec5b3f2abc28423fee55ca76dc7ef83ff5f730810357933ff2ceb6751304373ff1c7ae6c5a34753ff0adf86ea4dff03fee0f6ee35a65843ff572de41dd5c523fec3beb529576793feaa4c2f40916e43ff231500dbb6f1c3ffaa504de2f566d3ff8ba158b7431673fe50468d67b1ca73fe9cc78ae3248813fe5498288db1af93fe5c249656065473fe72d757018ae7e3fe34c9728061eb93ff356310bcb54173fe2b574d142d74c3ff7daba58c613b83ff626e7d0219cf23ff00ca9681e045d3fe6cd6abc99449e3ff317ffedc0a6533fe625acdbdc0d7e3feefb972e29ced83ff41175a55f7a053ff78e95d6383efd" + } + }, + { + "id": "certified-exp10-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff3ed1f5f4dcb654000c4578d6d9deb4007a2289bc9581840129305be3c9f2340045a4154e357753ffe700eb1a163a7401767f5072d30b63fe6825b80275034400280caddad77fe3ffb5010a95814e83fe247aaf8ca9af63fd74e818e87c07b400a953c0f62c8ba3fd0f756e2fa9a4a3fd0cabde6175a993fdd0b34681a9fc33fd0b888dd018ab63fe7e813ed3746243fc5c72a3dbef0513fca55b941f2418c3fe00a6c1a8b0c3740159f402cabd1f440020440dc2e472740088784ff604a243ff4d540f2c99e273fdea88bc1ed314c3fd307cd46ec42fb3fdb075167e5d09640012211d753de2f3ff673013b86d1f53fc45f625e5b008140150272c92030e1" + } + }, + { + "id": "certified-log2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff29fbe641751003fed26677e1788d6400768ef5fb9d1924005e23f7eb4f3c23ff529dce2a5888040017de724950e2d4003e126060acd8bbfc5b73520c88248c00005973fe9c87d3fd91c30622e357940017edb9f9071eabffe529e22de7b38bfd5f1ad00e5bad1400768a3637ef71c3feccf7712578b4d3ffad8b626cc0a0a3f8493c24f41c00dbfffd998cbb07a8f3fd4b24ae4dd514f3fff176ba7adbd4240050f5ff894cfc940041887f1b5d89140000db4d601cde64000f89aced6f8613ffc5223ceb75e5b4005f45d94a94d82400438fbe0eb1d943ff7a8f510410ed63ff4692f8b6b36693ffdbb19ed448bcf400048455e10834b400076d0bb25565e" + } + }, + { + "id": "certified-cbrt-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfeb7d4503c104c4bfe76ecea145b6e3bfed0a33ec8d12db3fe79648c8c63988bfe7a0f8e6dbcd30bfe9f08eb6e28a03bfe57d5d7229d0c5bfe7ed121102471f3fecc742474a903a3fe2d1251d243576bfe8a54b32dd7a4bbfe254ffd86be0003feb0114e424d8af3fe381fa79b64389bfeca1c25b815d8d3feb0cd9dd71c6fb3fe48331b0cdcb2ebfe9d45d093eca04bfed01734200afd6bfe55af26ae40d953fd8bc538c4d09d13fe7a732b0d5ec423fe76d424692b09ebfe3f908aac730a7bfe851337d5ca477bfe3ff9f08b435813fe2a1eb9186c5853fd00839adaeded9bfea9356644bc7643fe9622b703cb9e33fe886b4fe33bc57bfeb7eed7076d914" + } + }, + { + "id": "certified-lgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe054e856f6a1ba3fd6909cdeb44d1e400ead8575cb36553ff211f35814dc6f401bc283eb47440b400a04b8948099fd401b2451ab31bf143ff4db50ac67f7aa3ffe276976eca3013fe001a4439461664016a3c1e000b6f7bfb256c45c544278bfb7b7a4c19932d63ffa142d0efa57b9400c72f2c1ed33844012578ca4f6100d3ff7da23e77272403fcc822dfa34e40e400b750bf9bad006401c205c2cfbf1433ff1aadf17b1a02a4015bf4a64b48d81401a25726a7f1c64400d78e61b0b2b414011482dd4dc1a88bfbef0f9b7db1f2e40024a7cb89c5994400da5f6214f8f043fe5a9a9854c3a41400591b46550bf65400fc1bf9d0c22aa4009022b4742d636" + } + }, + { + "id": "certified-tgamma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 256, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40a9549578418af53ffa60646bb9cd5a3fef52b1140a24db406ca1f88eba91c140af6baa57ecec7f3fecc2d3b32d39893fef6af566571f5340043b55adfaa0503fed475aa31da4a6401ec999eda8ceea4007c4c24d359fd9400b158668d4a19840b1a22d45d2c8543fecca1a9148f09d40038848a92db9004005c66940e59a514005dadfd39a775d4071d3a71984e40a4004f74f5597200e40888855bff0c86b3fedfbe6d79bcdca4090be895f176d363ff05b8c6d34d065408944b05798e0d13ff464c73275c2a03feccdff408e4fec408aa0b6051b9a9440a8d542b7433ffd40b1f10459c8a9c4407615eb71c6674f404e9cf096fb10d44000b3b12b59aca5" + } + }, + { + "id": "certified-hypot-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 512, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "401ada0da261c1b03ffbcd4ee3604a18401e0bc024219ecc400b25b90b13db4d401f22153c4413a54015831fc7042b9b4002705eb6491582401545b1e7249dcc401e008b04a3cc73401df5dae63b9e213feb091416ce74644011bb1d12bff22440097781105d7a173fe2228c94a8b7d7401c763a3f983bb53fff5774891d31d340058a255e09c19140007ee90339c99d401a1ee2a0a93d41401ec222e7062d6d401cfe6fe9152a133fed2349edb2912c40033077a91205c8401582349ecf94cc401b82655f81cd49400f6dc9a8acfe97401b5339b0a4e9b54012a4eda263b2234018086fe6573aee401702d5263677f64008fca60be038a6401a5029fc336d5f" + } + }, + { + "id": "certified-atan2-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 512, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fa23a742b2419873fe4aec07c56878fbfb434166022448fbfa021969df11fa73fbc0a906e8f6ae3bfbff3586267569c3fb50d75ddda36053fb5a39f6a35f3bb3f9bbcda6927a81f3fe76f0fd9d3e0c43fc30301ab089fb23fc4e45fc4e8032bbfdc12944b321bdcbfcb733f706a0521bfc3fad50f96cd95bfb123960ab21916bf886c855abb17cd3fbb4ceab4a4b3023f8e3f6e86b581a93fcd80a3565250843fbed1a3c2ce0a103fb0f3750253ba723f8c99e52b42c9bbbfbb8d4cb3c58e613f89162cd21b8046bfb1c90fe95ca7d2bf832d0b37d722a93fe0a71ffcdf5e2d3fb6dd179e38f44d3fa7512ceb2c295c3fba5276c1d4ed803fab2cd062677ebb" + } + }, + { + "id": "certified-logaddexp-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 512, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff4379c961088c940173e485c6087c8401c4de3117064d3401ad5b80656be4540038f0ce893282b401382bbbc714c61401582ce924985a9401b0d88f4e61edc401d28d04de4e263400d1222a4bf6965401d169110496e1a400196971a6f2461401e78734004b7a0401afaeb4c6905cb4013d388cd078275401d736364b0b85640171ffd018c551c4001fcca12c7269540117fafdb2b9b2e401cd7c961d36d923ff7ab3b59aff84f400fcee405fd95264018ccd6a7b5c1384015d8441ea8f4c340126bbf874dcf3e402007f72ebc86cd401587aacd7c404d4015669a5892fcb9401277ec40202028401407314ea6b77d401b792a34ff6c9e4018a307a1c64193" + } + }, + { + "id": "certified-fma-float64", + "status": 0, + "category": "success", + "native_status": 0, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "reference_match": true, + "baseline_regression": false, + "outcome": "matching", + "normalization_bytes": 768, + "environment_restored": true, + "recovery_ok": true, + "mismatches": [], + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bffca1afbbaf3c103ff1443b35c2d0f0bfd54d30950a55b0bfd467db77e5c782400ea8c8acf18b3f3fa40af6b6f27fd2400348864b022ecebfd9b117a5af01d1bfeff2839101abba3fd3c41ec32a52f6bf73eba3634c6fc4c000b6950de331183ff08a80a957d73a400830321ca04bb74000297e0879e46bbffedfceef3c90a93feaa088e5da9f58bfe724ad8460a5e4c004da25d493889fc0061ca5ff2379043fe1a4632aad72a040031d28de85a32a3ff56a5ebc31c8a3c0064b1c47b8c6f7bfd578d85aa27a9bc00c3c592d4c0ec03ffc7ebdf56a7bbbbffe9648f89d233dbfe7532fcec84d01bfe952a969fe4b77bfba4faaac44a21a4010c2470a1811d2" + } + } + ], + "python": [ + { + "id": "signature-sin-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f576aa43f68c7b7", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f576aa43f68c7b7", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f576aa43f68c7b7", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003feaed548f090cee3fed18f6ead1b446", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f0a5140bed51133", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f0a5140bed51133", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f0a5140bed51133", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003fe14a280fb5068cbfdaa22657537205", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc75923c00bd7b1", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc75923c00bd7b1", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc75923c00bd7b1", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff8eb245cbee3a5c0017af62e0950f8", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f966cfe40681e7b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f966cfe40681e7b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f966cfe40681e7b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff2cd9fc44eb982400d03cf63b6e19f", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fc583ab4070c7d0", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fc583ab4070c7d0", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fc583ab4070c7d0", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff8b07551d9f550400e18fa0df2d9bc", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f42f7d63f76ca83", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f42f7d63f76ca83", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f42f7d63f76ca83", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-tanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe85efab514f3943feed9505e1bc3d4", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fb504f3", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fb504f3", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fb504f3", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sqrt-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff6a09e667f3bcd", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fa14518", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fa14518", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003fa14518", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-cbrt-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff428a2f98d728b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f800000402df85440ec7326", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f800000402df85440ec7326", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f800000402df85440ec7326", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000004005bf0a8b145769401d8e64b8d4ddae", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040800000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040800000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000040800000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-exp2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000004010000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fdbf0a940cc7326", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fdbf0a940cc7326", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fdbf0a940cc7326", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-expm1-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ffb7e151628aed340198e64b8d4ddae", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f800000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f800000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f800000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003ff0000000000000", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003e9a209b", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003e9a209b", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003e9a209b", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log10-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fd34413509f79ff", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f3172183f8c9f54", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f3172183f8c9f54", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f3172183f8c9f54", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-log1p-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe62e42fefa39ef3ff193ea7aad030b", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ceil-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-floor-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-trunc-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-rint-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-round-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f8000003f800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-sign-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000003ff0000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-square-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004010000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-conj-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-real-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-imag-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isfinite-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isinf-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-isnan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-signbit-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fabs-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-absolute-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-abs-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "ff800000000000003f317218", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ln-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "fff000000000000000000000000000003fe62e42fefa39ef", + "classes": [ + "negative_inf", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-acosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-asinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fc90fdb000000007fc00000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff921fb54442d1800000000000000007ff8000000000000", + "classes": [ + "finite", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003fc90fda7fc00000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff921fb54442d187ff8000000000000", + "classes": [ + "positive_zero", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f8db70d", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183ff1b6e192ebbe45", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003fa89214", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arccosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003ff5124271980434", + "classes": [ + "nan", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f61a1b33fb8c90c", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arcsinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fec34366179d4273ff719218313d087", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-minimum-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-maximum-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "010102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000100010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f80000040000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmax-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff00000000000004000000000000000", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fb504f3403504f3", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fb504f3403504f3", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003fb504f3403504f3", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-hypot-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff6a09e667f3bcd4006a09e667f3bcd", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-copysign-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000013f80000040000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000013f80000040000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000013f80000040000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-nextafter-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000013ff00000000000004000000000000000", + "classes": [ + "subnormal", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fa818f63fd8b90c402c5c86", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fa818f63fd8b90c402c5c86", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3fa818f63fd8b90c402c5c86", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-logaddexp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff5031eafefb0493ffb17217f7d1cf840058b90bfbe8e7c", + "classes": [ + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-fmod-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-remainder-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-power-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004010000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000004000000041000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000004000000041000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000004000000041000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-ldexp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000040000000000000004020000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-atan2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f490fdb3f490fdb", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-arctan2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003fe921fb54442d183fe921fb54442d18", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000104" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040800000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-pow-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004010000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f57bb3d3f57bb3d", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f57bb3d3f57bb3d", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f57bb3d3f57bb3d", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erf-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3feaf767a741088a3feaf767a741088a", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3e21130b3e21130b", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3e21130b3e21130b", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3e21130b3e21130b", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-erfc-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3fc4226162fbddd63fc4226162fbddd6", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-lgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f800000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f800000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3f8000003f800000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-tgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000000000003ff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4120000041200000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4120000041200000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4120000041200000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-exp10-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40240000000000004024000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-sinpi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-cospi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-bool", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-int8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-uint8", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fdim-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4000000040000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "40000000000000004000000000000000", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-float32", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-fac-float64", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-float32", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-ncr-float64", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00010001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000100000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000010000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-float32", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-npr-float64", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-e-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-extension-pi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-bool", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000101" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-int8", + "status": 0, + "category": "success", + "output": { + "dtype": "int8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-int16", + "status": 0, + "category": "success", + "output": { + "dtype": "int16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-int32", + "status": 0, + "category": "success", + "output": { + "dtype": "int32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-int64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-uint8", + "status": 0, + "category": "success", + "output": { + "dtype": "uint8", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000102" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-uint16", + "status": 0, + "category": "success", + "output": { + "dtype": "uint16", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000010002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-uint32", + "status": 0, + "category": "success", + "output": { + "dtype": "uint32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000100000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-uint64", + "status": 0, + "category": "success", + "output": { + "dtype": "uint64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000010000000000000002" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "000000003f80000040000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "signature-where-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003ff00000000000004000000000000000", + "classes": [ + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f0599b3bf68c7b7bf576aa4bef57744800000000000000000000001008000003ef577443f576aa43f68c7b7bf0599b37fc000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-cos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f5a5f96bed511333f0a51403f60a9403f8000003f8000003f8000003f8000003f60a9403f0a5140bed511333f5a5f967fc000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-tan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f1c9eca400bd7b1bfc75923bf0bda7b800000000000000000000001008000003f0bda7b3fc75923c00bd7b1bf1c9eca7fc000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff800000c0681e7bbf966cfebf056680800000000000000000000001008000003f0566803f966cfe40681e7b7f8000007f8000007fc00000", + "classes": [ + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-cosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f8000004070c7d03fc583ab3f90560c3f8000003f8000003f8000003f8000003f90560c3fc583ab4070c7d07f8000007f8000007fc00000", + "classes": [ + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-tanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf76ca83bf42f7d6beec9a9f800000000000000000000001008000003eec9a9f3f42f7d63f76ca833f8000003f8000007fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sqrt-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc0000080000000000000001a3504f3200000003f3504f33f8000003fb504f35f7fffff7f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-cbrt-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000d4cb2ff5bfa14518bf800000bf4b2ff5800000000000000026a145182a8000003f4b2ff53f8000003fa1451854cb2ff57f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-exp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003e0a95553ebc5ab23f1b45983f8000003f8000003f8000003f8000003fd3094c402df85440ec73267f8000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-exp2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003e8000003f0000003f3504f33f8000003f8000003f8000003f8000003fb504f340000000408000007f8000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-expm1-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf5d5aabbf21d2a7bec974d0800000000000000000000001008000003f2612993fdbf0a940cc73267f8000007f8000007fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c2ce8ed0c2aeac50bf317218000000003f31721842b172187f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c3150000c2fc0000bf800000000000003f800000430000007f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log10-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c23369f4c217b818be9a209b000000003e9a209b421a209b7f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log1p-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000ff800000bf317218800000000000000000000001008000003ecf991f3f3172183f8c9f5442b172187f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "negative_inf", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-ceil-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000003f8000003f8000003f8000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-floor-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf80000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-trunc-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-rint-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-round-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf8000008000000080000000000000000000000000000000000000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sign-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf800000bf800000bf80000000000000000000003f8000003f8000003f8000003f8000003f8000003f8000003f8000007fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-square-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f800000408000003f8000003e800000000000000000000000000000000000003e8000003f800000408000007f8000007f8000007fc00000", + "classes": [ + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-conj-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf000000800000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-real-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf000000800000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-imag-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-isfinite-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000101010101010101010101010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-isinf-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010000000000000000000000000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-isnan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-signbit-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010101010101000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fabs-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f8000003f000000000000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-absolute-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f8000003f000000000000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-abs-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f8000003f000000000000000000000000000001008000003f0000003f800000400000007f7fffff7f8000007fc00000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-ln-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc00000ff800000ff800000c2ce8ed0c2aeac50bf317218000000003f31721842b172187f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-acos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc0000040490fda40060a923fc90fdb3fc90fdb3fc90fdb3fc90fdb3f860a92000000007fc000007fc000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-asin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000bfc90fdabf060a92800000000000000000000001008000003f060a923fc90fda7fc000007fc000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-atan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bfc90fdabfc90fdabf8db70dbf490fdbbeed6338800000000000000000000001008000003eed63383f490fdb3f8db70d3fc90fda3fc90fda7fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-acosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc00000000000003fa8921442b2d4fc7f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-asinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000c2b2d4fcbfb8c90cbf61a1b3bef66165800000000000000000000001008000003ef661653f61a1b33fb8c90c42b2d4fc7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-atanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000ff800000bf0c9f54800000000000000000000001008000003f0c9f547f8000007fc000007fc000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "negative_inf", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "positive_inf", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arccos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc0000040490fda40060a923fc90fdb3fc90fdb3fc90fdb3fc90fdb3f860a92000000007fc000007fc000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arcsin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000bfc90fdabf060a92800000000000000000000001008000003f060a923fc90fda7fc000007fc000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arctan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bfc90fdabfc90fdabf8db70dbf490fdbbeed6338800000000000000000000001008000003eed63383f490fdb3f8db70d3fc90fda3fc90fda7fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arccosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc000007fc00000000000003fa8921442b2d4fc7f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arcsinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000c2b2d4fcbfb8c90cbf61a1b3bef66165800000000000000000000001008000003ef661653f61a1b33fb8c90c42b2d4fc7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arctanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000ff800000bf0c9f54800000000000000000000001008000003f0c9f547f8000007fc000007fc000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "negative_inf", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "positive_inf", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-minimum-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000ff7fffffc0000000bf800000bf000000800000008000000000000001000000013f000000bf80000040000000ff7fffff7f8000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "subnormal", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-maximum-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000000000000000000000400000008000000000000000000000000080000000800000400000003f8000007f8000007f7fffff7f8000007fc00000", + "classes": [ + "nan", + "positive_zero", + "positive_zero", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fmin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff7fffffc0000000bf800000bf000000800000008000000000000001000000013f000000bf80000040000000ff7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "subnormal", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fmax-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff8000000000000000000000400000008000000000000000000000000080000000800000400000003f8000007f8000007f7fffff7f8000007fc00000", + "classes": [ + "negative_inf", + "positive_zero", + "positive_zero", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-hypot-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff40000000400f1bbd3f000000000000000000000000800000008000004003f07b3fb504f37f8000007f8000007f8000007fc00000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-copysign-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f7fffff400000003f800000bf000000000000008000000000000001008000003f000000bf80000040000000ff7fffff7f8000007fc00000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "negative_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-nextafter-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000ff7ffffebfffffffbf7fffffbeffffff000000008000000000000002007fffff3f0000013f7fffff400000017f7ffffe7f8000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "negative_zero", + "subnormal", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-logaddexp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000000000003e01f96b40031c0e3ef2ba383f3172183f3172183f3172183f317218400ce3f53f903f2d7f8000007f7fffff7f8000007fc00000", + "classes": [ + "nan", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fmod-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc00000bf8000007fc000007fc000007fc0000000000001000000003f0000000000000040000000000000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "nan", + "nan", + "nan", + "subnormal", + "positive_zero", + "finite", + "positive_zero", + "finite", + "positive_zero", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-remainder-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000003f8000007fc000007fc000007fc0000000000001000000003f0000008000000040000000800000007fc000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "nan", + "nan", + "nan", + "subnormal", + "positive_zero", + "finite", + "negative_zero", + "finite", + "negative_zero", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-power-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003e8000003f8000007f800000000000007f8000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-ldexp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "ff800000ff800000bf800000bf800000bf800000800000000000000000000000004000003f8000007f8000007f8000007f8000007f8000007fc00000", + "classes": [ + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "positive_inf", + "positive_inf", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-atan2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000bfc90fdbbfc90fdbbeed6338bfc90fdb8000000040490fda340000003fc90fda3e7adbb04016cbe4000000004016cbe43f490fdb7fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arctan2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000bfc90fdbbfc90fdbbeed6338bfc90fdb8000000040490fda340000003fc90fda3e7adbb04016cbe4000000004016cbe43f490fdb7fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-pow-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003f8000003e8000003f8000007f800000000000007f8000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "ties-rint-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c0800000c0000000c00000008000000000000000400000004000000040800000", + "classes": [ + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "ties-round-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c0800000c0000000c00000008000000000000000400000004000000040800000", + "classes": [ + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-erf-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3e8d7aa73f053f7b3f57bb3d3f7ecd71", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-erf-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bf800000bf800000bf7ecd71bf57bb3dbf053f7b80000000000000000000000100906ebb3f053f7b3f57bb3d3f7ecd713f8000003f8000007fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-erfc-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3f3942ac3ef5810a3e21130b3b9947af", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-erfc-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "40000000400000003fff66b83febdd9f3fc29fbe3f8000003f8000003f8000003f8000003ef5810a3e21130b3b9947af00000000000000007fc00000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-lgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fa4ddec3f1286820000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-lgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7f8000007f8000007f8000007f8000003fa1fc4d7f8000007f80000042ce8ed042aeac503f12868200000000000000007f8000007f8000007fc00000", + "classes": [ + "positive_inf", + "positive_inf", + "positive_inf", + "positive_inf", + "finite", + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-tgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "406809fe3fe2dfc53f8000003f800000", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-tgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000007fc000007fc000007fc00000c062dfc5ff8000007f8000007f8000007e8000003fe2dfc53f8000003f8000007f8000007f8000007fc00000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "finite", + "negative_inf", + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exp10-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe39ea9404a62c24120000042c80000", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-exp10-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000003c23d70a3dcccccd3ea1e89b3f8000003f8000003f8000003f800000404a62c24120000042c800007f8000007f8000007fc00000", + "classes": [ + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-sinpi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3f3504f33f8000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-sinpi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc00000800000008000000080000000bf80000080000000000000000000000301490fdb3f8000000000000000000000000000007fc000007fc00000", + "classes": [ + "nan", + "negative_zero", + "negative_zero", + "negative_zero", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "positive_zero", + "positive_zero", + "positive_zero", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-cospi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3f3504f300000000bf8000003f800000", + "classes": [ + "finite", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-cospi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000003f8000003f800000bf800000000000003f8000003f8000003f8000003f80000000000000bf8000003f8000003f8000007fc000007fc00000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-fdim-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000003f800000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-fdim-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc0000000000000000000000000000000000000000000000000000000000000007fffff0000000040000000000000007f800000000000007fc00000", + "classes": [ + "nan", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "subnormal", + "positive_zero", + "finite", + "positive_zero", + "positive_inf", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-fma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "bf400000bf000000000000003f800000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-fma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7fc000000000000000000000c000000000000000000000000000000000000000000000003f800000bf8000007f800000ff8000007f8000007fc00000", + "classes": [ + "nan", + "positive_zero", + "positive_zero", + "finite", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "positive_inf", + "negative_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-fac-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000060000000000000018" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-ncr-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-npr-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-e-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b1457694005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-pi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bf7452fc98b34e97bfed18f6ead1b446bfeaed548f090ceebfdeaee8744b05f080000000000000000000000000000000000000000000000100100000000000003fdeaee8744b05f03feaed548f090cee3fed18f6ead1b4463f7452fc98b34e977ff80000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-cos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bfefffe62ecfab75bfdaa226575372053fe14a280fb5068c3fec1528065b7d503ff00000000000003ff00000000000003ff00000000000003ff00000000000003fec1528065b7d503fe14a280fb5068cbfdaa22657537205bfefffe62ecfab757ff80000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-tan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003f74530cfe72948340017af62e0950f8bff8eb245cbee3a5bfe17b4f5bf3474a80000000000000000000000000000000000000000000000100100000000000003fe17b4f5bf3474a3ff8eb245cbee3a5c0017af62e0950f8bf74530cfe7294837ff80000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000fff0000000000000c00d03cf63b6e19fbff2cd9fc44eb982bfe0acd00fe63b9780000000000000000000000000000000000000000000000100100000000000003fe0acd00fe63b973ff2cd9fc44eb982400d03cf63b6e19f7ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-cosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007ff0000000000000400e18fa0df2d9bc3ff8b07551d9f5503ff20ac1862ae8d03ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff20ac1862ae8d03ff8b07551d9f550400e18fa0df2d9bc7ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-tanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bfeed9505e1bc3d4bfe85efab514f394bfdd9353d7568af380000000000000000000000000000000000000000000000100100000000000003fdd9353d7568af33fe85efab514f3943feed9505e1bc3d43ff00000000000003ff00000000000007ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sqrt-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000800000000000000000000000000000001e6000000000000020000000000000003fe6a09e667f3bcd3ff00000000000003ff6a09e667f3bcd5fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-cbrt-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000d54428a2f98d728bbff428a2f98d728bbff0000000000000bfe965fea53d6e3d8000000000000000000000000000000029900000000000002aa428a2f98d728b3fe965fea53d6e3d3ff00000000000003ff428a2f98d728b554428a2f98d728b7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-exp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003fc152aaa3bf81cc3fd78b56362cef383fe368b2fc6f960a3ff00000000000003ff00000000000003ff00000000000003ff00000000000003ffa61298e1e069c4005bf0a8b145769401d8e64b8d4ddae7ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-exp2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003fd00000000000003fe00000000000003fe6a09e667f3bcd3ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff6a09e667f3bcd400000000000000040100000000000007ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-expm1-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bfebab5557101f8dbfe43a54e4e98864bfd92e9a0720d3ec80000000000000000000000000000000000000000000000100100000000000003fe4c2531c3c0d383ffb7e151628aed340198e64b8d4ddae7ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c0874385446d71c3c086232bdd7abcd2bfe62e42fefa39ef00000000000000003fe62e42fefa39ef40862e42fefa39ef7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c090c80000000000c08ff00000000000bff000000000000000000000000000003ff000000000000040900000000000007ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log10-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c07434e6420f4374c0733a7146f72a42bfd34413509f79ff00000000000000003fd34413509f79ff40734413509f79ff7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-log1p-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000fff0000000000000bfe62e42fefa39ef80000000000000000000000000000000000000000000000100100000000000003fd9f323ecbf984c3fe62e42fefa39ef3ff193ea7aad030b40862e42fefa39ef7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "negative_inf", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-ceil-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000003ff00000000000003ff00000000000003ff00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-floor-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bff0000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-trunc-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-rint-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-round-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff00000000000008000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-sign-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bff0000000000000bff0000000000000bff0000000000000000000000000000000000000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000007ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-square-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007ff000000000000040100000000000003ff00000000000003fd000000000000000000000000000000000000000000000000000000000000000000000000000003fd00000000000003ff000000000000040100000000000007ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-conj-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-real-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-imag-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-isfinite-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000101010101010101010101010000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-isinf-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010000000000000000000000000100" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-isnan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000001" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-signbit-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "bool", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "010101010101000000000000000000" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fabs-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff00000000000003fe000000000000000000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-absolute-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff00000000000003fe000000000000000000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-abs-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff00000000000003fe000000000000000000000000000000000000000000000000000000000000100100000000000003fe00000000000003ff000000000000040000000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-ln-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000fff0000000000000fff0000000000000c0874385446d71c3c086232bdd7abcd2bfe62e42fefa39ef00000000000000003fe62e42fefa39ef40862e42fefa39ef7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-acos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000400921fb54442d184000c152382d73663ff921fb54442d183ff921fb54442d183ff921fb54442d183ff921fb54442d183ff0c152382d736500000000000000007ff80000000000007ff80000000000007ff8000000000000fff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-asin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff8000000000000fff8000000000000fff8000000000000bff921fb54442d18bfe0c152382d736580000000000000000000000000000000000000000000000100100000000000003fe0c152382d73653ff921fb54442d187ff80000000000007ff80000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-atan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff921fb54442d18bff921fb54442d18bff1b6e192ebbe45bfe921fb54442d18bfddac670561bb5080000000000000000000000000000000000000000000000100100000000000003fddac670561bb503fe921fb54442d183ff1b6e192ebbe453ff921fb54442d183ff921fb54442d187ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-acosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff800000000000000000000000000003ff5124271980434408633ce8fb9f87d7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-asinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000c08633ce8fb9f87dbff719218313d087bfec34366179d427bfdecc2caec5160a80000000000000000000000000000000000000000000000100100000000000003fdecc2caec5160a3fec34366179d4273ff719218313d087408633ce8fb9f87d7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-atanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000fff0000000000000bfe193ea7aad030b80000000000000000000000000000000000000000000000100100000000000003fe193ea7aad030b7ff00000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "negative_inf", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "positive_inf", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arccos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000400921fb54442d184000c152382d73663ff921fb54442d183ff921fb54442d183ff921fb54442d183ff921fb54442d183ff0c152382d736500000000000000007ff80000000000007ff80000000000007ff8000000000000fff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arcsin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff8000000000000fff8000000000000fff8000000000000bff921fb54442d18bfe0c152382d736580000000000000000000000000000000000000000000000100100000000000003fe0c152382d73653ff921fb54442d187ff80000000000007ff80000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arctan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff921fb54442d18bff921fb54442d18bff1b6e192ebbe45bfe921fb54442d18bfddac670561bb5080000000000000000000000000000000000000000000000100100000000000003fddac670561bb503fe921fb54442d183ff1b6e192ebbe453ff921fb54442d183ff921fb54442d187ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arccosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff80000000000007ff800000000000000000000000000003ff5124271980434408633ce8fb9f87d7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "nan", + "positive_zero", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arcsinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000c08633ce8fb9f87dbff719218313d087bfec34366179d427bfdecc2caec5160a80000000000000000000000000000000000000000000000100100000000000003fdecc2caec5160a3fec34366179d4273ff719218313d087408633ce8fb9f87d7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arctanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000fff0000000000000bfe193ea7aad030b80000000000000000000000000000000000000000000000100100000000000003fe193ea7aad030b7ff00000000000007ff80000000000007ff80000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "negative_inf", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "positive_inf", + "nan", + "nan", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-minimum-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000008000000000000000000000000000000100000000000000013fe0000000000000bff00000000000004000000000000000ffefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "subnormal", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-maximum-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000000000000000000000000000000000000040000000000000008000000000000000000000000000000000000000000000000010000000000000001000000000000040000000000000003ff00000000000007ff00000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "positive_zero", + "positive_zero", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fmin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000ffefffffffffffffc000000000000000bff0000000000000bfe000000000000080000000000000008000000000000000000000000000000100000000000000013fe0000000000000bff00000000000004000000000000000ffefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "negative_zero", + "subnormal", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fmax-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff00000000000000000000000000000000000000000000040000000000000008000000000000000000000000000000000000000000000000010000000000000001000000000000040000000000000003ff00000000000007ff00000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "positive_zero", + "positive_zero", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-hypot-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000004001e3779b97f4a83fe0000000000000000000000000000000000000000000000010000000000000001000000000000040007e0f66afed073ff6a09e667f3bcd7ff00000000000007ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-copysign-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007fefffffffffffff40000000000000003ff0000000000000bfe000000000000000000000000000008000000000000000000000000000000100100000000000003fe0000000000000bff00000000000004000000000000000ffefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "negative_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-nextafter-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000ffeffffffffffffebfffffffffffffffbfefffffffffffffbfdfffffffffffff000000000000000080000000000000000000000000000002000fffffffffffff3fe00000000000013fefffffffffffff40000000000000017feffffffffffffe7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "negative_zero", + "subnormal", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-logaddexp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000003fc03f2d54301d4940006381c3f0115c3fde5746fdb5c0643fe62e42fefa39ef3fe62e42fefa39ef3fe62e42fefa39ef3fe62e42fefa39ef40019c7e908f54213ff207e5aa8603a97ff00000000000007fefffffffffffff7ff00000000000007ff8000000000000", + "classes": [ + "nan", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "finite", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-fmod-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff8000000000000bff00000000000007ff80000000000007ff80000000000007ff8000000000000000000000000000100000000000000003fe00000000000000000000000000000400000000000000000000000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "nan", + "nan", + "nan", + "subnormal", + "positive_zero", + "finite", + "positive_zero", + "finite", + "positive_zero", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-remainder-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000003ff00000000000007ff80000000000007ff80000000000007ff8000000000000000000000000000100000000000000003fe00000000000008000000000000000400000000000000080000000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "finite", + "nan", + "nan", + "nan", + "subnormal", + "positive_zero", + "finite", + "negative_zero", + "finite", + "negative_zero", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-power-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003fd00000000000003ff00000000000007ff000000000000000000000000000007ff00000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-ldexp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000fff0000000000000bff0000000000000bff0000000000000bff000000000000080000000000000000000000000000000000000000000000000080000000000003ff00000000000007ff00000000000007ff00000000000007ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "negative_inf", + "negative_inf", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "positive_zero", + "subnormal", + "finite", + "positive_inf", + "positive_inf", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-atan2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bff921fb54442d18bff921fb54442d18bfddac670561bb4fbff921fb54442d188000000000000000400921fb54442d183cb00000000000003ff921fb54442d173fcf5b75f92c80dd4002d97c7f3321d200000000000000004002d97c7f3321d23fe921fb54442d187ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-arctan2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000bff921fb54442d18bff921fb54442d18bfddac670561bb4fbff921fb54442d188000000000000000400921fb54442d183cb00000000000003ff921fb54442d173fcf5b75f92c80dd4002d97c7f3321d200000000000000004002d97c7f3321d23fe921fb54442d187ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "exceptional-pow-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000003fd00000000000003ff00000000000007ff000000000000000000000000000007ff00000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_zero", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "ties-rint-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c010000000000000c000000000000000c00000000000000080000000000000000000000000000000400000000000000040000000000000004010000000000000", + "classes": [ + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "ties-round-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 8 + ], + "encoding": "raw-be-hex", + "hex": "c010000000000000c000000000000000c00000000000000080000000000000000000000000000000400000000000000040000000000000004010000000000000", + "classes": [ + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-erf-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fd1af54e232d6083fe0a7ef5c18edd23feaf767a741088a3fefd9ae142795e3", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-erf-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "bff0000000000000bff0000000000000bfefd9ae142795e3bfeaf767a741088abfe0a7ef5c18edd280000000000000000000000000000000000000000000000100120dd750429b6d3fe0a7ef5c18edd23feaf767a741088a3fefd9ae142795e33ff00000000000003ff00000000000007ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-erfc-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe728558ee694fc3fdeb02147ce245c3fc4226162fbddd63f7328f5ec350e65", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-erfc-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "400000000000000040000000000000003fffecd70a13caf23ffd7bb3d3a084453ff853f7ae0c76e93ff00000000000003ff00000000000003ff00000000000003ff00000000000003fdeb02147ce245c3fc4226162fbddd63f7328f5ec350e65000000000000000000000000000000007ff8000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-lgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3ff49bbd81c16efb3fe250d048e7a1bc00000000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-lgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff00000000000007ff00000000000007ff00000000000007ff00000000000003ff43f89a3f0edd67ff00000000000007ff000000000000040874385446d71c34086232bdd7abcd23fe250d048e7a1bc000000000000000000000000000000007ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_inf", + "positive_inf", + "positive_inf", + "positive_inf", + "finite", + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "positive_zero", + "positive_zero", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-tgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "400d013fc47eeeea3ffc5bf891b4ef6b3ff00000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-tgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000007ff80000000000007ff80000000000007ff8000000000000c00c5bf891b4ef6afff00000000000007ff00000000000007ff00000000000007fd00000000000003ffc5bf891b4ef6b3ff00000000000003ff00000000000007ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "nan", + "nan", + "nan", + "nan", + "finite", + "negative_inf", + "positive_inf", + "positive_inf", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exp10-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3ffc73d51c54470e40094c583ada5b5340240000000000004059000000000000", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-exp10-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "000000000000000000000000000000003f847ae147ae147b3fb999999999999a3fd43d136248490f3ff00000000000003ff00000000000003ff00000000000003ff000000000000040094c583ada5b53402400000000000040590000000000007ff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "positive_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-sinpi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe6a09e667f3bcc3ff000000000000000000000000000000000000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-sinpi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000800000000000000080000000000000008000000000000000bff0000000000000800000000000000000000000000000000000000000000003002921fb54442d183ff00000000000000000000000000000000000000000000000000000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "negative_zero", + "negative_zero", + "negative_zero", + "finite", + "negative_zero", + "positive_zero", + "subnormal", + "finite", + "finite", + "positive_zero", + "positive_zero", + "positive_zero", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-cospi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "3fe6a09e667f3bcd0000000000000000bff00000000000003ff0000000000000", + "classes": [ + "finite", + "positive_zero", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-cospi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000003ff00000000000003ff0000000000000bff000000000000000000000000000003ff00000000000003ff00000000000003ff00000000000003ff00000000000000000000000000000bff00000000000003ff00000000000003ff00000000000007ff80000000000007ff8000000000000", + "classes": [ + "nan", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "finite", + "finite", + "positive_zero", + "finite", + "finite", + "finite", + "nan", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-fdim-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000000000000000000000000000000000003ff0000000000000", + "classes": [ + "positive_zero", + "positive_zero", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-fdim-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000fffffffffffff0000000000000000400000000000000000000000000000007ff000000000000000000000000000007ff8000000000000", + "classes": [ + "nan", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "subnormal", + "positive_zero", + "finite", + "positive_zero", + "positive_inf", + "positive_zero", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-fma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "bfe8000000000000bfe000000000000000000000000000003ff0000000000000", + "classes": [ + "finite", + "finite", + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-exceptional-fma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 15 + ], + "encoding": "raw-be-hex", + "hex": "7ff800000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ff0000000000000bff00000000000007ff0000000000000fff00000000000007ff00000000000007ff8000000000000", + "classes": [ + "nan", + "positive_zero", + "positive_zero", + "finite", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "positive_zero", + "finite", + "finite", + "positive_inf", + "negative_inf", + "positive_inf", + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-fac-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000060000000000000018" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-ncr-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-npr-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "int64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001000000000000000200000000000000030000000000000004" + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-e-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "4005bf0a8b1457694005bf0a8b1457694005bf0a8b1457694005bf0a8b145769", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-pi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 4 + ], + "encoding": "raw-be-hex", + "hex": "400921fb54442d18400921fb54442d18400921fb54442d18400921fb54442d18", + "classes": [ + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-domain-fac", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-float-reject-fac", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-domain-ncr", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-float-reject-ncr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-domain-npr", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "extension-float-reject-npr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "where-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3f8000004000000080000000", + "classes": [ + "finite", + "finite", + "negative_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "where-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "3ff000000000000040000000000000008000000000000000", + "classes": [ + "finite", + "finite", + "negative_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "status-invalid", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "7ff8000000000000", + "classes": [ + "nan" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "status-divide", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "fff0000000000000", + "classes": [ + "negative_inf" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "status-overflow", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "7ff0000000000000", + "classes": [ + "positive_inf" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "status-underflow", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000000", + "classes": [ + "positive_zero" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "status-clear", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "4000000000000000", + "classes": [ + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "status-lazy-where", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000004000000000000000", + "classes": [ + "positive_zero", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-sin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-cos", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-tan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-sinh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-cosh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-tanh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-sqrt", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-cbrt", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-exp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-exp2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-expm1", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-log", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-log2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-log10", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-log1p", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-ceil", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-floor", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-trunc", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-rint", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-round", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-sign", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-square", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-conj", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-real", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-imag", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-isfinite", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-isinf", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-isnan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-signbit", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-fabs", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-absolute", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-abs", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-ln", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-acos", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-asin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-atan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-acosh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-asinh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-atanh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-arccos", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-arcsin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-arctan", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-arccosh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-arcsinh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-arctanh", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-minimum", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-maximum", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-fmin", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-fmax", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-hypot", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-copysign", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-nextafter", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-logaddexp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-fmod", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-remainder", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-power", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-ldexp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-atan2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-arctan2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-pow", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-erf", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-erfc", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-lgamma", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-tgamma", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-exp10", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-sinpi", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-cospi", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-fdim", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-fma", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-fac", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-ncr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-npr", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-e", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-pi", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "arity-reject-where", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "spelling-reject-float-power", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "spelling-reject-logaddexp2", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "spelling-reject-heaviside", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "spelling-reject-spacing", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "spelling-reject-frexp", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "spelling-reject-modf", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "backend": "none", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sqrt-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40105d8e3ff2010b3ecf06eb402b212f3ff09d163fe26b5240052a793fc89d8940094087402a03843fd056e640081a6f4011d2013f527df7402d1e95401dc1023ee6007b3f77ac403f56292b3fcc07a13fd0fb0340209ffd3f96db6140208f4d4006bada4007ec5f3faeabf0403007b5401c56354000d47540022247401acaf5", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-exp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f813d1b3f8724c5400a58663efbef813f021fd23f8bff413fd7959b3fd3a1073f31e89b3f949bd43ffad1273fbdc30c3f990fb83fb445c63fdbfc353f0b765e3fe8b0683ff53f703fdd4cbf3f4684193f9764853f07d5803f628dd73f9e3c783f629c443fc238073fbeffb93f29bcba3f80e7873f0ca8073fc19f063fb29f08", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-expm1-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "be99f8f43f4b334ebf0b574c3eaf7a75bf0b8cf6befbbd9cbf05a2c5be9022ae3eee010bbeff6c3a3f6d3fba3f903ffd3e82c68bbe8d6c773f8d6a963f36f312bef50acdbe3b52e03f176d523f76d5a23f15f6843e0e132dbe95f42b3f512cdd3ed1ae9bbecaecf13f8c7b4abe2378ca3e5780633e1b9c663e32de9e3f16c859", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fafe8f73ff051663fe8309c3f9c33913fa598c43f6f69533fd0c91e3fefd8e83fcca67c3f95f94f3f0cd4e64001742f3e0a2e773f40a9e5be92c2603fd1d8c73febe7663f5806323fad18363f94eaf23fe3f8513fcf36633febb32f3ff32fa43f9828023fc67ff13ff003183ea6670f3fdf163e3fe3b66f3ebe29e2bfa442fa", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log10-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f08c0d63f4acee6bf1f75c83f46cce8bd2c6ac93f38283c3f2ab4dc3f21116f3f0ab6c43f44775d3f1a04403f3769133f567652bf1f26aa3e4fa7463deb93b73f6097b53ea1f5243e28fe833f3cbbee3e66b61c3f3ae929bf09f95f3ed428cb3f5f70d73f65912a3f47a33d3cc44de43f33cc2e3f57eb023f50d38b3f3e5993", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log1p-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bec18fd5be23a284bf8db1b33eac6b8c3eace35f3ef04f89bc50e3e9bee7d0843e48c7d73f0b614ebfc75e6abf429ca43de9c11a3d617799bd7b0ade3dd410a9bfb47cf3be9bb5923ea9cd773f04c2e6bf280d26bf57e827be1c0b913ecfe6abbe7170e63d5195f43e3231d1be2c1ff6bd92560ebfb68558bd5aed57bed5785b", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e90b434bd93cbad3e745e673a8e77e3bea240cc3effe444bee149fbbeb64be53c8a0b30bf0abcbabe6fe597bf1b47bb3ed2427dbf33ad98bf27578fbec8fcdfbb8b6562bf189be33ea17b4e3e5652be3e8a85acbd45b842bf1e487b3ec9e6c6bda90f2fbf292d0c3eae305c3eb898643f051468bf04cf77bf14b4febf03c68b", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f7ffc033f549cb03f36b8743f4a6b463f78c57f3f7f3b753f758c0d3f6469513f7cb6903f76d5893f78af4f3f7ae0ab3f7a31a73f7ffa373f64356c3f7b94d63f775ff03f7d1cc63f6686d63f55e1c93f7ebde53f6963293f731fc63f5e5a1d3f62cd723f61fbb93f5e56973f7a4b6f3f5a452c3f7ef69a3f7eaa013f3b994c", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-tan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf30792c3f65c7803edf6621bf8355d03e9afa1dbf791bce3edc2a0a3e2f94c43d5873113e1f804abe5a0dc2bf3193dc3e98c6c2bf4ca6583f82324bbb8a28ef3f275a773f4326f13e31309e3f0c324bbf6de3d03f0ca5193ebb7082be805cea3e852f92bf1312e1bf7ad958bdc0b60cbe93b2f1bf4750b6bf468002bf465ec5", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-asin-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf57cf763f16650f3e9c1ac03ed0a6d23e9b73f3bf54dda4be4407c9bd14b5d8be762717bedafdaabdd008d0bf1d0c2d3e164435be8fe9773dfc59ecbe1f07ce3f64240b3e95412fbf36d9df3f16a82a3f157edc3f2e35613e55b1163e6949163e9751483e6c99f73f0e7ef9be759bd8beba52e93e611600bef00540bf177f14", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-acos-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fd864ad3f5e6b673fa71a313fd0fa073fcbc77b3f6e78143ff7690f3f5ad1683f9bc89c3f9d0b523fbe26424014a2a43f6f65e74005c02e3fab4fbb3fd4e6e63fa3d8ca3f414538401f2a223f3a9d423f4c17e33f70ef8b3f8d22be3fa64f993f9981b63fbd09303fd54980401afacd3fe8cbbe3f91903f3f5182923fb0a6f8", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-atan-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf2c528c3e9d6ce63f02d22abe03a07c3f1783233ec846ba3f19d5fd3eca6df7be5fc6f63f110bdbbf229731bea656e83d8d290e3ee2c7e7bc47f180bedb39583f0d01e23ddd9ba6bf066206bf2980dcbe02e65abe82f820becd09d2be4e8b80beb3cad03e99a332bf12aba73eaf3775be5f93f83e2acf9dbe002c343ef5e556", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f5e67963ec641a43f36285bbefde3f43ee8406e3e74d40f3f0af65abf4f1bc73f526aa0be2e41183f624160becbfaaebe5159273f446ed33e77910a3f1601d13e50d35dbf2d092f3ef6de40be84aea03dd3a80a3f14dd47bf547d9c3e53e7f53db02e5f3e247052bf5c04bbbf197828bf08250fbf305c0bbf24ff733ee7c75c", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f850fee3f847be43f875e3e3f8159d33f97e6383fa6528c3f88ba3b3f825e883f9893bb3f807f8d3f84d87b3f815ec63fa726473f900dbc3f80ea4e3f8aea283f9004683f83ccb83f8499203f9ad3673f80f49d3f8066df3f9750c23f8505063fa6070c3f96ba803f9e098f3f81af843f8029073f8dbdf13f80f7953f80577a", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-tanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e61ef53beb515ee3e3e0d81bed252c53ef504753e0e8383bf0396abbf1668603eb280033f1406413f03d769bee9ae563ea7721b3e5a6419be54f5663d8c83573eddf2053f276c54beda11d3bf219dbb3dfd0be1be914fcc3ec970a3bef5845dbf2218f53eef8b633f18275bbd4593fbbe8110533ed690fcbf24e159bf019fef", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-asinh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "be9b06b1bef70d09be968df83e9367ed3f212b50be8ed979b981e86ebe8b485cbedb1637becce82ebf0137bf3eb576133f1dfa6dbf06fd35be7ba7133ed7c179bdef7f113db56790be14b300bedea40ebe244b6bbed0b831be9620a03e8fa4dbbf17a1813f3866c4bf005be6bea358ecbeaa1f6dbe457a733ec121583e81dc52", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-acosh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "401a177d4024e7354023e0cc40036ad03f982fe14008133a3ffcd4773ffe9df03fc93bca3f7b0d013fccdc4b3fc3048b3fd1d2453fa0bce53ed4bdb83fbded193fe6639740236d773fb4063e3fd8616d400ceae73fa7414e401a6a9c401577bd40279a9d3fcc276b3ff8706d3fafb6c040224e313ec2598c40231b8a400ad9a6", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-atanh-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e8632dbbe22c68d3ef507d3bf2b250d3ed9a0a73e6a4923bf7ac3c53e375387bd614dea3ebcdfe53e8d8f39bdbbd68dbee6c7793f39bf903f1f138d3d013735bd1c33e8beb4d316bf86c132bf822bf13e48a0343ee52d85bf2681923f5505b03f4738043edddf963e2ccd813f155747bf524b85bed4bec73f1c2adfbec9421d", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-erf-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf0481ee3f35d43d3db7b4353f08ffedbec9f49a3f0d8e8d3edb1f043f3516563de04e4dbf37abf23f3df04b3e1a4cc23ea96917bee4b4683babff19bf09b686be7d2dd6bec00a8ebee892063efb4f063f0e5e073f3b055ebec53f993e3f0f9b3f3149b63dd54fbabeeb0d3d3f276090be309378be6fe1933f1ae877bf243d28", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-erfc-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f3a00b83edbb9613fae6a543fbf4cd13f1426ef3f9dfc7e3f88e5b83f74b6583f60dc213f6380c43ea1734e3fd9323a3f6b053e3ead882c3f169dc63f21f8583f912fd03fbfeeae3fb5fe003fa61d9d3f1534933fdd6e283f8cd1ce3f955c323e914fa23fa74f383ee06dcb3f146ee03fb401503ef744c53f5b0c993fc28ab9", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sinpi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f44d2a2bf67b1083f29c6c9bf6282b8bf7dc236bf7ef96d3ed93ff1bf3792cdbee57bb4bf7ed6ea3e6985913f11af743f5379d2bf66ad293ec23b573f5751713f1ec5363f78c2cb3f754e1ebf586036bf12f3e23f451781bf7856fe3f35d6733f5434813f08f5dbbf55a835bf7dee8ebf273d463f7fc0643f42a7943f78ead0", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cospi-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e9c8c0cbe4d19ae3f778d8c3f4d93833f6bc1f1be5ebe87be07aa643ec95cfbbe9d0ef23f65ec413f30f05e3f36e9e83eeb69293f7fb5553f719ebbbf065be1bde9b67fbeb5c0653e3c8bd7bf1492a4bec8c5b43ed65d683f5418e6be6b979d3f750f8bbedb1f90bf2503ce3f72f63f3ead62163e35305dbd74f210bf425070", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-exp2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3f993ed43f1e63e93f21ce3c3fdc0c183f17c5033f5ff2333f9782de3fab9aef3fd878773f6b98893f7cc71d3f32587e3f581f0c3f5613a63f615cf03fa547363faf26f53fcbf4933f847a913fd919843faa474c3f1328413f9dea4f3f4bf0d83f870d1d3fbcc4713f6c28fd3faff87e3fb3e2133fba420c3f975eb33f9034b7", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-exp10-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3e5cca2f3f1dc935406d14363f000b3b40c8fb9e3e2ead5c3e49fb6a3ea0f4113fa72d233e6369dc3e96418d3f1cd5733ff79dcd40a842b43f2196453fbc911440113d4a406fdfcf3e43aa193f4e57fe409516d53e89a906409953813f7b399f3f6cfe393e87b3793e2859da401d521c3ee799c23e3823e83ec17816407646a7", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40285017bf0d0acb4034f09d402369d73fe2ac103f06a682401d431a40067a4c4014d7e6beb430f7403177903fd607f340144756402f1afc40183fbb4023809e3fd0073e3f6061a23f047c54403cd7143f2042d33f2785033fec2170bec717773fdb10453ff69f8a3ff954fb403e39de3ff09122bf582e074024500abfd365d2", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cbrt-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bf1a50aebf3f30bdbf3b696cbf4f80403f447bbebf661625be6f01043f2bb0203f4fa4393f680a1ebf482bc3bef443c5be864d4c3ecb2526bf62cbf8bf35de08bf1feda5bf536884bf222f8ebf51df5a3f6c3ba8bf6d0993bf2cf6643f4f32f0bf4ec8353f66610dbf286d53bf4f03df3f462ae13f6823f3bf046a873e9c06e5", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-lgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "405195ff404e573c3fa2166140b9658abc81d4684105e9414064196740768a713f80c67540c4b30c40eb493ebdebfc9340a07de940cacb443fcdeb503f9e1b9e3f63661240af7d69400dad203f96792abdf8cd21410259f940f5b4db4025b71bbded74833c27b0fc402ea56f40ee5eac3e25b85a3fd9038e3d820a313ff0ddc9", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-tgamma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "4481d56e41bb56283f67f9b243d99468411f928e4095a5bc408195c7412edc6344ec102c41ca2e2a426996ce3f7daec2421be1af42beb0da40841a8442c4c01f41d24f9b445fde7a44610723402d598242efcf234048675d4273b12d4312ea89458674664215f82140d1777a402af16a40385ffc437cdbc83f64bfaa3f69efb4", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-hypot-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40843bab40ca83cc407bc72d4076ada23e84650d40879d063f8ff1ec4091f9b640de2dfd40c58bde40b9130940a285f640dfe1c44082ea4b4083e1023feae4a840111eb04053289740e78e87404a6b12409f0bbf3fd3789740df201040a8426f4006f0904021a315400113f940e867c73f42ea393f5cf8da3fef896d407d0411", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-atan2-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "be8590e4bded1ffd3daa93ea3d4be5ebbeb8aca8be693288bd8083003de40e013dbb097c3f1aea43bd0ea23fbdac6ca73dd733933d1be51ebb1f85d9bd56e947bd47a1613e2924743dab71a1bcabbbc8bd3d016e3dced4373ee94bf2bbfba658bca54aec3ce1a724bf1ab09e3a7cd97cbe67d01f3d342a36bd1b663fbdb66c4d", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-logaddexp-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40f8c9e63fb8ae2e40456765407b59fc40eb52c640e3b3e940c261f940f0da7840055d98409eccc04095d07040da7a4b40f5ca44406fd07341004f1140d7bebc40f3554740e8dafe4055e03640f594cb40f35f944048ee1a40afebd740e5fbc240d9db2a4106f1194053c3b640d01e174064afd140ba4a8b3f62e44f40f6fdaa", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-fma-float32", + "status": 0, + "category": "success", + "output": { + "dtype": "float32", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "400e6b73c07aeaeebe95c3ff3fa60e26c06006503fcd0f8fbf6b0a0d3f9db340409b1b6ebfb86cecc0920af5c0b2bb44c0110ababec3a464403c5ee8bfaaf170c0305e573f000441bf509ca0c098de0a401c05004004ac56bf96e38ebea14e4ac09987e1beb4c83bbecf9c83bf935e9cbe72b635bfeb93913fb0b9d23f72011c", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sqrt-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40003be8662a5fb43ff17d28dc1939d73fe623ff8594f5134005f50bdba3cfa540022734b7acbe413fe5dab668b3126a3ff8830c80c000c040047d7528c7308c4000a5a085a5fb6f4003aa06c7aa116b3ffb8df4e0636edf400461bc406b5b363ff433e1a470ddd33fffd91365146a303feef157252cefb23ff69d2c9bd4e8b04003d54ef6f2cc214002b56471febdfa3ff8c777799bd1bd3ffa5d1df156e0c74003b8210119791d3ff75d4ca9afac9b400553f493d117e84001a2b63ee8e1304002f7e74f1b86423ff94ecafd04225b40020f39e7bb6d354003e2f7546ef0b93fe795aa4a607a703ff75fec854d201840063eb18a3c0e433ff5d9e8925f837c", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-exp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe8cf9f96d70f593fde973644f9fe663fe22892e4bd6fc83fde2afb2405f5ca3ff4f3ad24acf3543ff276fc441d4c7e3ff85b2c3a62884a3feb1d51a7be45183fe0580d424f06d03fe2856852b6b2cd3ffc56e39ce7883b3ff4e7d08112b6323fe180894c24ec303fe24ba3156c25403fea5c9f5478a61c3ff3fb0072939be53ffbac769a77e3c63fdd6bdb37e5f93b3fe21f21ef5347f13fe8316adbad314a3fe6287f6861891240013928063665063ffc58e0be6f4dcf3ff9d3d50b310ddc3ff1aac8b1af41583fdf70d2db4edc263ffbc07c126f951e400107d1869c407f3ff483a8ce871ec53fe14ee49e5fc72e3ff2e0c8c04ac3cc3ff56f7c46e28ebc", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-expm1-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe9994f99c2353d3fe0f0dd923a55c23ff0ff0acbbbdde43fd6ce5ec8f5a963bfd3ee3010b035433fe4d1b06cf9a6b9bfd7a42be64b6b2fbfc35e481f8c8c983fdf05ecaf28cd293fc9c3121379f2df3ff199b6b52859223fc1007234619bda3fdc8d4918a2b58b3ff12e4c166a19063fc9551cc084b1153fe794bae832df62bfd1f36036d8c761bfe16d612e0b56eebfb59b8e79fa3f573fd60de7116536a8bfe0276d018418023fc3007f6f9e1eb6bfc53c8b9bcb70bbbfce7a377a90754c3fd9db676c58b1fcbfd5c651af351a4ebfde5c9d5569fe61bfdf5cd019caaa56bfdf6ebcefe3569c3fa00d1d7526dc44bfd1f9ab36007df8bf7a57d512bdefd5", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffbfdba27e447593ff3b55a0f5454153fff592f8c5ba6b53ffcf225e992e8273ffa320b51a1a8cd3ffa319b87b6396b40005046b8575b764000159cf0870b7dc0013c869a3ce87d3ff643b42dbf22d3400090ed49d4c7233ff208ea175be4e33fe6389c0dc8ccb9bfe5cefd96631f053ff9533cd948d2cf3ff3827c220bc4333fb3c2c074d326e93fd349eb0c10fc893ff53c0c5f54b4af3ffe1549a786d979bfe16a78239041763ffd3a0d5b12531c3ff4b556378365453ff97930157530a93ff7ee65ad2306eb3ff874f431d61d773ff22cd5bb5d03dd3ff15a62aa91d2d83ff537ecd46687053fddf8e68cd2f7a63feedc8fea7679ec3ff884ddcb1ba4a9", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log10-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe758a636fe51e73fe5002664c1db7f3fece4c1c8b1d4a33feade0934d8c1ed3fe41f1044d168553fd0aa1642ea02623fe0aa839c8cb9693fe6a48e374c63693fe4c5531621d8183fd4f853951fde483fe623f9b0290cfe3fd8a019b3d537083fb1a7987ccf6f9d3febe97e41dcbc8c3fe298b3bf9545643fe4960c8c2fc32c3fe82e1df671dfa93fe60d9f6a208e7d3fc61053c258b7f93fe68ddf0bfc706c3fd70e04133f25493fe31b1462690adc3fec139cbc73a2aa3fe9cd9f705cfa683fec1a84550ef3873fec4180205cb59c3fd9d8c6e2afdcb43fec455099710ba43fce6ce02ea308463fea8817fc28b2b5bfd3b93549806d513fdb2774a4544804", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log1p-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfc1e43d085cb220bff13126bea0a058bfaff5c51259f2493fddf06fbac80775bfe9fd5d586aa21fbfc4e81a78f39a3dbfedcdb22b08e4153fd47d4aed5dbf5a3f93f360310ae91e3fadf3db18443cc03fae723753b0ff01bfee8d2f0bdfe0c33fd71745a00d8fcfbfed4f9c20edf5403fc59e24761b9d73bfb444cefe38a0d9bff03696740d7437bff8c0d16edfdfb43fc5dbfcde040cb53fd43d31524b5f74bf742f939938c3c73fd39cf310c8f106bfbd8d5a8e30f6593fe1b8406a2e69413fbea632ede9ca833fe1f038a8ee9d81bfea7403198a5e67bfd9a31cb26494e23f92b7abb69900d0bfe710ab762b4596bff512711a21f5813fdf55b3093c2b57", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfd647eab328f2ecbfe6291ae1148e213fe1a935f0b136a13fd7395ed31883f2bfdd4c30aefa15f83fd18b3b83f4ee9abfe0ea4d243841083fc65359928d381c3fe0775a321b6625bfe16fabcb340447bfc9f585059082f5bfd48a739e28ad193fe67824a911a33abfe2f08f76520d683fd480b6f8de53d53fc50739e7392bcc3fe2187a52fd65e93fd8fc770f947e4c3fb83164779f5b273fdf9fa6fc91e5933fe1bae938ef4e31bfd709a0d77e44163fcbe6e3f98944333fe4e22af1f74dfbbfe361d961d2b456bfd2c5038afd99213f966d5f53d18531bfdad2d4a1ae6425bfda0b58126e6e823fd556e30c7a50b1bfe48c22be57217f3fc9654224c13bdd", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fec927e8d46bd4b3fe8cf43dedb55613fedcd55b454550b3fed448cabf4b6ca3feeb77e3de6f2f23fe946cad1c8d39b3fe99307eb9a2e593febc9455c4b8fd63fecc39afe638a0a3fee67362375dd503feb75d227f50f123fe89917254c41f53fefe6644a10bcd63fee1243c57839783fe668f376c1364a3fee1d1a98482dab3fee9fa15fb834293fefa3af114ce1153fe9b9c72c65eef33fea18fe77eec69c3fef24afa878db383feff53821de16ff3fe83fab5ac1eb383fecbd9be970c7fa3fee2a8f36ed48443feb8e6f2f4a57933fec9dcc5b9693533fe7edc621a534c13febe5867a0d93873feea1f95b38e9843fe9b8a67f0593403fec0670b4fa43b7", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-tan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fbc22a4754c7723bfbb2ff162f7e1ef3fe484c5c4e68cd73fea6066615a78bdbfd9e3fa24aa753c3fb6e718eba13806bfd585aba0dfae343fd13e1b2e534f55bfa0135db053c7023fe0a0d0009ed35fbfe065a708874beebfe9cba2fd5cdb093fe2bcaace7746703fefd6ff78539a75bfd6860f77880102bfe9d755ac77151dbfe14d5596872181bfc198e97bdb60a8bfb3609f435fbc943fb547c23964e4d53fe8e026bf1d6baabfb1eb131a7c1725bfd2568d655e7e673fed17dc7dcd2d003fd8d1e28a25cd9d3fa175cf4d0c4df23fc99e524e62d1b4bfe6be39de491c91bf9d1021a344d8263fe2a944f2b2666b3fa57208eca541be3fe4f5a32f3b728a", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-asin-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfcdeb737886df7cbf9434bbf155299dbfe2fcea06d87a563fe47b43fcb8e7b7bfd011a1ac1e625ebfe9b5cc70cfda7b3feb7443f209d02b3fb0f59c9ec64c7dbfc76a64cb137fbe3fc5381e282159b33fe060da87699f16bfdbb2be92b1639a3fc6209ee8a8a359bfe51aa1f65f15783fc78a781c3ef0b23fdba292a63cfa103fecb94afb688c943fca99248f69e8963fdcb9b265b58f283fe7843bb68b87be3fd31c108a3e41a4bfaf9e98188d767e3fdf57358add1820bfe1342170e2359fbfeb0ff5e6a12c24bfea38afd6a059673fd96b816b476f4ebfcd5eef3f467f883fc09f78ffdeb96f3fc743ed75b60db9bfe1363cece4c6c33fe6c732e77052ef", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-acos-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffdc2a1ed76f657400334e7afc7ae463ff79306871934fc3ff943a498efca6b3ffceb7ca092e14b3feddddc9479606d3ffde1e9cdee834e400299b061ba22863ffdb7a505867eaf3ffbae7e2e40adf240016c58bf14b4543ffb8ccd9dfb47c23ffef52dca78d2c63ff8daa82cd429323ff0187c8e68517e3ff85a159b504c103ff7811950f6916c400033681307d76f4001650312a79e483fe9e78ac0f0f0cc3ffd1152fbbc4b163fed69ee8c1457c13ffd472197c58e163ff930bea2f4d8083ffceee4eacdec603ff91ff75763de3f3ff72e2da6dc056d3fe931936832a186400231162bfd22c73ff5edf113eb21d23ff4610df319313a3fffdab65eb33a0b", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-atan-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfdd863c3d652057bfe0816ba8cb539fbfe3ad7933637c1b3f9216bdb63a4110bfce42afb42d17223fd65cdb57e9ef5ebf79138d3bb8b8e8bfc5aba918ec311e3fcece03fb099fff3fc13edee8b3e80dbfde36fe8ca5ed47bfdc4106022d18523f9e20697262be1ebfb882ab90ebc5123fe1b23502609678bfd31be3f9deb599bfd20fed9f747fac3fdc8ffeba95b8213fe2df04b3457a57bfa0d232e7ce3d46bfcaebc219a9eb473fb989ab8f0c605cbfe28c9f0564930f3fd0fd3c916d79fdbfdad8c22ff506f13fceb1d7cdb7210bbfe4b91727e8fbd3bfe2359994863420bfbbdb0c5729803d3fc5b1180a2e0aed3fdcc20b75dc7b2a3fa1c1ec12adafeb", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fd19901c946010bbfd919a26f4012ee3fe77c4966e838843fe3f9cff6a25a60bfd314cc38e45b47bf90c4798ddc6765bfd298142c317d2f3fd3d73b21e26a153fb2f45db0a03850bfd9f881142814ffbfe8c4ffac1ae37f3fdd3bb9738bde0b3fd27e36469fd39dbfd83e54f77d29893fe04be86700029a3fda58c1bbe7c4dc3fe6adc8b89e45253fe12c5d9b5770703fdf8fc172e0343e3fe53ced0d965f543fe55a935b0f47783fc278ec018e051e3fda5c92e11835c93fe04ae809f93975bfe0571dbe680e94bfc8d98b2aa135e73f84b26827e2f72d3fe97f1e5ccfb8f8bfe922fb6a6ddc073fdbf43cabf9f6c4bfc23a1d66e57d683fa16f93a5107320", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff00000104974ad3ff13210db66d4cc3ff06ff09a981f1a3ff26784b5e8fe073ff53c169b64a4f73ff0c994f9a236cb3ff015656ceb44683ff54d2939c6181c3ff4d6af82cb62c93ff0aa57053a2a1b3ff53844d9f98cc73ff0fc725b643e9c3ff03496a3af4d563ff00229b76fe61b3ff22d35b1a6f6b03ff1c2f9e05a83513ff2949f0aea731f3ff33e2373e7a4c53ff13d63c11ee4f83ff000156d64ce3c3ff49f55c513efd73ff09f068bb8c6323ff32382bde5abf53ff08ecf02bd06c23ff029ab606955a73ff2ac8e32a430fc3ff284e70a6af2213ff3c3f3000596813ff0011ab5d3c2a73ff0721c4fd1664b3ff490148a2bd9903ff0df56f3dabeaf", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-tanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfbee46032fe52773fd74e1af233c3d1bfddf718f5219c6c3fd91ac90f1935d7bfb4d65829a35a5cbfda4b83e7bf89233fe4dab1b34790593fdd6f8b6afecede3fe38a0aa112cc3ebfe34fbc988d59b7bfac2787891f65103fdc4e696100d9e9bfc8c9abb31b8e29bfd9b3a232017aa93fd343fadd7cf6793fdee904385cc1f83fdd214b34b35e92bfe2997dec11b6bebfc2d4520eee200ebfd4c2299e6710753fd7b75691eb781e3fe4f4bbd4d87858bfe2e3e4afaaa2843f7dfe963ad125ac3fe294717f500b23bfd40a063a3c15ed3fc31bdf754639a53fe12f2428857e2fbfe14bb86690b6c23fd666074260facfbfda0c3675ec1e62bfd29c4deaf85f05", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-asinh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfbd5b8ff223eb51bfd337fdb364bdb13fdb4ef46374d476bfcada9ac78b85f33fe45a8b77c6151fbf785e4746f1bb75bfc63d341bc5c507bfe13c20959fd58c3fe366867168f59e3fe743c51d8a68ebbfe56c22cca534123fe0df9dd7cad652bfdba0741613dae23fc5dac93556d05abfe747a1942c59a5bfe25b465acc15d1bfd93601214bd4923fe12b26d8ad2d5abfe676c1277ceb793fdad985453f784e3fe0d4236e30ee3f3fe747f4579bc7233fdcf952239b20283fc2edb2836ea7a1bfe5bfd5bf1c797bbfe31455d60870e4bfe14f526aaa6c763fb2f2f9638a54793fb5d5fc414b90f33fc862a3bbc27b8e3fd09483edc9532a3fe14dd5a918344b", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-acosh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe108a6b75517844004aabab23c133c4002c031bb5493803fd5364e30c4c35040049ee43f4963ee40020f5eda9b274240038517047c220a3ffde5873a7993aa4000ad6a99cb3c463ffb11590dce29b24002e9043bdfb3b24002d88c6bae7ec64002eb0defe4cad940041926694d64a24002c5f9ccd5d9623ffd253684fa8ea040047097138710b73ff39e9ab8989c5e4006050c707031464004c3102021eaf34000c8ebdfb31f8b400336136f0692bf400114520e1ddbd73ff7016eb7ea07ab40060ab1dafff62f4005c5bb216411644003354e66d05029400176395344c472400235b13a1b81723ffc0f415cd6a1e440031ff067f01a2d3fec7d0363f3cdbf", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-atanh-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe0350dcbbd2f4ebfcb488839fa5fcd3fdcf12f3c8b29d1bfe7188d3ed13b9d3fbfb6dedc329b99bfbdae05a0ad2154bfa3203b10965771bfe19fa143dfd2a43fcdbf2d1b3ffab8bfe4328c11bb09713fbd43f7412d7b503fe8f90785109f8abfe10a8144dc3b7ebfe0839e1feb9a1cbfae42b740dea087bf83af8e02375c7c3fb5468f370352b3bfe49b8f309239db3fca7acdaac03c87bfeea3a963619c1c3fe2f306f85c6d16bf7628e971fb015abfd8a5046350ec72bfc7a0fdedf51de8bfba7ff42c3345a8bfd3904555d14de23fef6ff9f2f06efa3fdaefe527d990b53fdf8f5ca686ebf03fe8fc384b032ca2bfed2b6521fe1badbfd45961e61e7795", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-erf-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfa5ed3b201e964d3fd3c600207a6e53bfb01bc434178b12bf9e5a98c565d19d3fe56750da2c74efbfda1c4ecc20f047bfb4c8726d4f2cc0bfde9fbdaeb47109bfd6f4ad2f537bf8bfc2cbd367b177d23fcf910ebf59bb6f3fb715414a9f4a1e3fd304d30ecb2daabfe63817610e3e843fe51fbfba6dc870bfdfa72d1fd5adf23fe4fec48063f6f8bfb8d42ab7abc5173fce5917af6536643f36dface3fa49babfa4c550012a6e79bfe3ee6a7650803c3fa4cf2ac187fc91bfe13a9f513203733fe78b8ec7356ef63fbb7ed121aec54f3fe5e1c7dbe2b37dbfc1ffb0f461e3d43fe04d26493232983fd4b5585f4228eebfdbde5e6d66692fbfe012885513e3fd", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-erfc-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffba9c30d961d143ff60c839f7dba803ff4f55d2271a8c63fd6365ee8699b2b3fd863728ba2d9a63fd7d26807cee88a3fd2e260396fc8a53ff3eabdc7e0d5023fdfffddd340f2b13fd762d8feda5a3d3fe895a539a274933fd110e7a988148d3ffb11b6d1a427ad3ffa7e6a80a800b93ff567a86641154a3ff34ff8c8381e323ff4af35c8d358a93ff6fcb92751b5f23ff93b1e0935214c3ff6b034359d41e73fde8a45f67859753ff83b8e393f4d0d3ff971758a42579b3ff5d33e2ff371883fe12ec95e7ead053fdb2eddb75393863ff915df9e12f1903fe5ec27c3a584bc3fd2f6c6ed730a2c3fe44656344073443ff995a6ac0af7873fe0c1432b1a2465", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-sinpi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfeff938701472ae3fe2e2e9f3f11e833febe1753ef3d7c63fe03a112106abd73fe35e49907032113fd4f79031660e02bfeab501e15b4162bfee34937a9566f8bfeabbf9c1ce1a86bfe80c68fbe54d0cbfeffb3a434aff113fefba89814f470abfedcf1d965c96c43fe6d607c4623692bfed3732794cdb67bfedf475dbbfab04bfeffb3f02c7f0303fe0cbdf8d5c42343fea98a23b0bbfdcbfe6e58da49347d1bfee19c9716d4b51bfee64bc8317b3523fe828c2a37176a3bfeffee75d2280a0bfefc8fe21a32c0ebfed4642dc6f3bd2bfd06b077db262db3fe3fc1b486ebc2c3fefd61fbdc00fadbfec2e05885d6efcbfed77293142bf923fee928244579119", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cospi-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fefa70dd5948ebc3fe3a726d3dadb773fe8ed4c466d9e163faab7dcaceb5a1abfd76625553b8d74bfd0ed208babf834bfd79923e3498e15bfc224c4bed2d2893fc9977f14c86b703fedd3c655ef24aa3fa7949b44f4ee403fefdf24f8a7c9163fc33e878c108d473feffe42e3ce3b133fe0a6c8644d71e6bfbe69c17675cb023fb173729518e024bfc10898c95080f53fd352dc6f3912d63fd21d64f21179973fb2d39f877b385bbf9abe29b571526bbfb7f6790e33f7efbfdd05c4d34fb088bfa2c57607c812d53fefa138219816be3fdbd8b289341e413fef795df9d9e15bbfe8d912ccb5c05c3fc5ac36e44951223fee107594b5bbc03fd79214bbbb7cf8", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-exp2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ffae27d2096a6c93fef2f5d3d84e50e3fec5b3f2abc28423fee55ca76dc7ef83ff5f730810357933ff2ceb6751304373ff1c7ae6c5a34753ff0adf86ea4dff03fee0f6ee35a65843ff572de41dd5c523fec3beb529576793feaa4c2f40916e43ff231500dbb6f1c3ffaa504de2f566d3ff8ba158b7431673fe50468d67b1ca73fe9cc78ae3248813fe5498288db1af93fe5c249656065473fe72d757018ae7e3fe34c9728061eb93ff356310bcb54173fe2b574d142d74c3ff7daba58c613b83ff626e7d0219cf23ff00ca9681e045d3fe6cd6abc99449e3ff317ffedc0a6533fe625acdbdc0d7e3feefb972e29ced83ff41175a55f7a053ff78e95d6383efd", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-exp10-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff3ed1f5f4dcb654000c4578d6d9deb4007a2289bc9581840129305be3c9f2340045a4154e357753ffe700eb1a163a7401767f5072d30b63fe6825b80275034400280caddad77fe3ffb5010a95814e83fe247aaf8ca9af63fd74e818e87c07b400a953c0f62c8ba3fd0f756e2fa9a4a3fd0cabde6175a993fdd0b34681a9fc33fd0b888dd018ab63fe7e813ed3746243fc5c72a3dbef0513fca55b941f2418c3fe00a6c1a8b0c3740159f402cabd1f440020440dc2e472740088784ff604a243ff4d540f2c99e273fdea88bc1ed314c3fd307cd46ec42fb3fdb075167e5d09640012211d753de2f3ff673013b86d1f53fc45f625e5b008140150272c92030e1", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-log2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff29fbe641751003fed26677e1788d6400768ef5fb9d1924005e23f7eb4f3c23ff529dce2a5888040017de724950e2d4003e126060acd8bbfc5b73520c88248c00005973fe9c87d3fd91c30622e357940017edb9f9071eabffe529e22de7b38bfd5f1ad00e5bad1400768a3637ef71c3feccf7712578b4d3ffad8b626cc0a0a3f8493c24f41c00dbfffd998cbb07a8f3fd4b24ae4dd514f3fff176ba7adbd4240050f5ff894cfc940041887f1b5d89140000db4d601cde64000f89aced6f8613ffc5223ceb75e5b4005f45d94a94d82400438fbe0eb1d943ff7a8f510410ed63ff4692f8b6b36693ffdbb19ed448bcf400048455e10834b400076d0bb25565e", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-cbrt-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bfeb7d4503c104c4bfe76ecea145b6e3bfed0a33ec8d12db3fe79648c8c63988bfe7a0f8e6dbcd30bfe9f08eb6e28a03bfe57d5d7229d0c5bfe7ed121102471f3fecc742474a903a3fe2d1251d243576bfe8a54b32dd7a4bbfe254ffd86be0003feb0114e424d8af3fe381fa79b64389bfeca1c25b815d8d3feb0cd9dd71c6fb3fe48331b0cdcb2ebfe9d45d093eca04bfed01734200afd6bfe55af26ae40d953fd8bc538c4d09d13fe7a732b0d5ec423fe76d424692b09ebfe3f908aac730a7bfe851337d5ca477bfe3ff9f08b435813fe2a1eb9186c5853fd00839adaeded9bfea9356644bc7643fe9622b703cb9e33fe886b4fe33bc57bfeb7eed7076d914", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-lgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fe054e856f6a1ba3fd6909cdeb44d1e400ead8575cb36553ff211f35814dc6f401bc283eb47440b400a04b8948099fd401b2451ab31bf143ff4db50ac67f7aa3ffe276976eca3013fe001a4439461664016a3c1e000b6f7bfb256c45c544278bfb7b7a4c19932d63ffa142d0efa57b9400c72f2c1ed33844012578ca4f6100d3ff7da23e77272403fcc822dfa34e40e400b750bf9bad006401c205c2cfbf1433ff1aadf17b1a02a4015bf4a64b48d81401a25726a7f1c64400d78e61b0b2b414011482dd4dc1a88bfbef0f9b7db1f2e40024a7cb89c5994400da5f6214f8f043fe5a9a9854c3a41400591b46550bf65400fc1bf9d0c22aa4009022b4742d636", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-tgamma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "40a9549578418af53ffa60646bb9cd5a3fef52b1140a24db406ca1f88eba91c140af6baa57ecec7f3fecc2d3b32d39893fef6af566571f5340043b55adfaa0503fed475aa31da4a6401ec999eda8ceea4007c4c24d359fd9400b158668d4a19840b1a22d45d2c8543fecca1a9148f09d40038848a92db9004005c66940e59a514005dadfd39a775d4071d3a71984e40a4004f74f5597200e40888855bff0c86b3fedfbe6d79bcdca4090be895f176d363ff05b8c6d34d065408944b05798e0d13ff464c73275c2a03feccdff408e4fec408aa0b6051b9a9440a8d542b7433ffd40b1f10459c8a9c4407615eb71c6674f404e9cf096fb10d44000b3b12b59aca5", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-hypot-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "401ada0da261c1b03ffbcd4ee3604a18401e0bc024219ecc400b25b90b13db4d401f22153c4413a54015831fc7042b9b4002705eb6491582401545b1e7249dcc401e008b04a3cc73401df5dae63b9e213feb091416ce74644011bb1d12bff22440097781105d7a173fe2228c94a8b7d7401c763a3f983bb53fff5774891d31d340058a255e09c19140007ee90339c99d401a1ee2a0a93d41401ec222e7062d6d401cfe6fe9152a133fed2349edb2912c40033077a91205c8401582349ecf94cc401b82655f81cd49400f6dc9a8acfe97401b5339b0a4e9b54012a4eda263b2234018086fe6573aee401702d5263677f64008fca60be038a6401a5029fc336d5f", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-atan2-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3fa23a742b2419873fe4aec07c56878fbfb434166022448fbfa021969df11fa73fbc0a906e8f6ae3bfbff3586267569c3fb50d75ddda36053fb5a39f6a35f3bb3f9bbcda6927a81f3fe76f0fd9d3e0c43fc30301ab089fb23fc4e45fc4e8032bbfdc12944b321bdcbfcb733f706a0521bfc3fad50f96cd95bfb123960ab21916bf886c855abb17cd3fbb4ceab4a4b3023f8e3f6e86b581a93fcd80a3565250843fbed1a3c2ce0a103fb0f3750253ba723f8c99e52b42c9bbbfbb8d4cb3c58e613f89162cd21b8046bfb1c90fe95ca7d2bf832d0b37d722a93fe0a71ffcdf5e2d3fb6dd179e38f44d3fa7512ceb2c295c3fba5276c1d4ed803fab2cd062677ebb", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-logaddexp-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "3ff4379c961088c940173e485c6087c8401c4de3117064d3401ad5b80656be4540038f0ce893282b401382bbbc714c61401582ce924985a9401b0d88f4e61edc401d28d04de4e263400d1222a4bf6965401d169110496e1a400196971a6f2461401e78734004b7a0401afaeb4c6905cb4013d388cd078275401d736364b0b85640171ffd018c551c4001fcca12c7269540117fafdb2b9b2e401cd7c961d36d923ff7ab3b59aff84f400fcee405fd95264018ccd6a7b5c1384015d8441ea8f4c340126bbf874dcf3e402007f72ebc86cd401587aacd7c404d4015669a5892fcb9401277ec40202028401407314ea6b77d401b792a34ff6c9e4018a307a1c64193", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + }, + { + "id": "certified-fma-float64", + "status": 0, + "category": "success", + "output": { + "dtype": "float64", + "shape": [ + 32 + ], + "encoding": "raw-be-hex", + "hex": "bffca1afbbaf3c103ff1443b35c2d0f0bfd54d30950a55b0bfd467db77e5c782400ea8c8acf18b3f3fa40af6b6f27fd2400348864b022ecebfd9b117a5af01d1bfeff2839101abba3fd3c41ec32a52f6bf73eba3634c6fc4c000b6950de331183ff08a80a957d73a400830321ca04bb74000297e0879e46bbffedfceef3c90a93feaa088e5da9f58bfe724ad8460a5e4c004da25d493889fc0061ca5ff2379043fe1a4632aad72a040031d28de85a32a3ff56a5ebc31c8a3c0064b1c47b8c6f7bfd578d85aa27a9bc00c3c592d4c0ec03ffc7ebdf56a7bbbbffe9648f89d233dbfe7532fcec84d01bfe952a969fe4b77bfba4faaac44a21a4010c2470a1811d2", + "classes": [ + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite", + "finite" + ] + }, + "backend": "interpreter", + "requested_backend": "jit", + "jit_eligible": false, + "jit_skip_reason": "portable draft has no eligible JIT route", + "recovery_ok": true, + "reference_match": true, + "mismatches": [], + "baseline_regression": false, + "outcome": "matching" + } + ] + } + } +} diff --git a/plans/menudet-m4-signoff.md b/plans/menudet-m4-signoff.md new file mode 100644 index 000000000..405f5c1fc --- /dev/null +++ b/plans/menudet-m4-signoff.md @@ -0,0 +1,123 @@ +# M4 — functions and exceptional-value semantics + +Date: 2026-10-09. Reference: NumPy **2.5.3**. + +## Outcome and acceptance scope + +M4's declared real function matrix and native floating-status policy are +implemented in opt-in portable **1.1**. Checked 1.0 exports, existing artifacts, +dependency pins and default backend routing are preserved. Implementation/matrix +acceptance is complete; cross-native-platform qualification remains pending +Linux/Windows CI execution, not silently inferred from macOS results. + +The authoritative native corpus is +`../miniexpr/tests/numpy-compat/functions-v1.1.json`; its independent Python +generator/reference reader is `tools/menudet_functions.py`. The native contract +is documented in `../miniexpr/doc/numpy-functions-1.1.md` and Python usage in +`doc/reference/portable_dsl.rst`. + +- **75 spellings, 825 signature rows, 1,154 passing contract cases.** +- **668 NumPy-reference cases**, **486 native-contract cases**, including + **230 diagnostic cases** across the complete corpus. These categories must not + be conflated into 1,154 NumPy numerical parity passes. +- **64 independently certified finite cases × 32 samples**, seed **20261009**, + using 100-decimal-digit mpmath references. All discrete/exact and bounded + transcendental comparisons have explicit policies. The 8-ULP sampled bound is + not a proof of correctly-rounded libm or a global bound over all real inputs. +- Shared C/Python off/on execution agrees, with **empty NumPy reference drift**; + provenance, corpus/runtime hashes and results are in + `plans/menudet-m4-conformance.json`. +- Portable **JIT/SIMD eligibility remains zero**. On requests exercise the + interpreter fallback, not accelerated semantic conformance. + +## Implemented behavior + +Classification, distinct `minimum`/`maximum` versus `fmin`/`fmax`, and aliases +`absolute`/`fabs` have native typed execution. The matrix includes arithmetic +helpers, rounding, sign, power, selection, logarithmic/exponential/trigonometric +and hyperbolic functions, stepping/sign primitives and existing libm extensions. +Tests cover all advertised real spellings and arities, accepted/rejected input +types, inferred dtype, normal/subnormal boundaries, signed zero, NaN/infinity, +domain limits, ties and large/small magnitudes. + +The signature audit corrected `rint`, `fabs`, small-integer real-math promotion, +Boolean `square`/`conj`, Boolean `imag`, integer `fmin`/`fmax`/`fmod`, one-argument +ties-even `round`, divisor-sign `remainder`, and zero-sign `sign`. Float32 uses +float libm operations; no output dtype drives intermediate arithmetic. +NumPy float16-result signatures explicitly reject rather than silently widening. + +Native `me_artifact_eval_status()` supplies cleared per-call stable invalid, +divide, overflow and underflow flags, configurable raise masks, caller fenv +restoration, scoped thread-local collection, valid-mask participation and +selected-lane branch semantics. Cross-block aggregation is caller-owned OR; +there is no mutable cumulative state on compiled handles. Python exposes +`return_status=True` and `fp_errors='ignore'|'raise'`; exceptions include +`.fp_status`. Default execution continues ignoring floating flags without warnings. + +A full-suite regression exposed newly registered predicates entering legacy +full-DSL nullable-table routing. These spellings are now profile-gated to 1.1; +eight dedicated routing regressions and the existing 76-test nullable-logic module +verify that legacy routing remains unchanged. + +## Explicit divergences / capability limits + +- `where` evaluates only selected lanes; eager NumPy branch-argument diagnostics + are intentionally not reproduced. Masked operations do not contribute flags. +- Extrema signed-zero ties follow deterministic IEEE min/max rules. NumPy tied + zero bits vary with array length/SIMD/platform. Floating extrema vectors are + marked native-contract rather than disguised NumPy references. +- Native extensions lacking a NumPy equivalent use explicitly declared contracts. +- Unsupported spellings, float16 loops, extra rounding arguments, ufunc methods + and tuple-valued functions are recorded and reject source validation. +- Reporting is an IEEE-operation flag policy, not full `np.seterr`: no inexact, + warning counts, callbacks, or synthesized integer floating warnings. Internal + libm flags can differ from NumPy vector-loop diagnostics. +- WASM has no observable fenv exception flags: reports `supported=False`, not a + false exception-free claim; raising rejects before execution. Values and policy + rejection are tested; native flag assertions are capability-qualified. +- Linux/Windows execution, NumPy 1.26 integration, release-wheel qualification + and eligible portable acceleration are outstanding qualifications. + +## Reproduction + +Use the `blosc2` conda environment. The editable extension must explicitly use +the sibling checkout; no dependency pin was updated: + +```sh +conda run -n blosc2 python -m pip install -e . --no-build-isolation --no-deps \ + --config-settings=cmake.define.FETCHCONTENT_SOURCE_DIR_MINIEXPR=/Users/faltet/blosc/miniexpr +conda run -n blosc2 python -m tools.menudet_functions \ + ../miniexpr/tests/numpy-compat/functions-v1.1.json +conda run -n blosc2 python -m tools.menudet_conformance run \ + ../miniexpr/tests/numpy-compat/functions-v1.1.json \ + --native-runner "$BUILD/tests/numpy_compat_runner" \ + --work-dir "$WORK" --report plans/menudet-m4-conformance.json +MENUDET_NUMPY_FUNCTION_CORPUS=/Users/faltet/blosc/miniexpr/tests/numpy-compat/functions-v1.1.json \ +MENUDET_NUMPY_RUNNER="$BUILD/tests/numpy_compat_runner" \ + conda run -n blosc2 pytest tests/test_menudet_functions.py -q -n 0 +conda run -n blosc2 ctest --test-dir "$BUILD" --output-on-failure +``` + +Native CTest registers the same off/on function corpus for native platform CI, +sanitizers and Node/WASM. C and Python readers assert status behavior independently; +native reporting requests also check raise-mask errors and recovery. Python tests +add same-handle concurrent isolation and explicit cross-block aggregation. + +## Final validation + +- Full Python suite: **12,286 passed, 55 skipped**, after correcting the + reproducible legacy nullable-table routing regression. +- Complete native CTest suite: **425 passed**. +- ASan/UBSan shared-corpus/example checks: **9 passed**. +- Standalone Node/WASM shared-corpus/example checks: **9 passed**. +- Focused Python M4 tests: **21 passed**, also **21 passed** against the + sanitized C runner. +- Paired C/Python corpus: **1,154 cases × off/on**, all contract checks pass; + reference drift is empty, eligible portable acceleration is zero. +- JSON Schema validation, Ruff lint/format and both repository whitespace checks + pass; independent corpus regeneration is identical. Native, sanitizer and WASM + rebuilds emitted no new compiler warnings. +- Sphinx HTML build succeeded; it emits existing project-wide missing autosummary, + duplicate-label, theme and cross-reference warnings. No warning in the modified + portable DSL reference was observed. Editable build configuration also emitted + dependency CMake deprecation/policy warnings, not new compiler warnings. diff --git a/plans/menudet-m5-m6-signoff.md b/plans/menudet-m5-m6-signoff.md new file mode 100644 index 000000000..75253e2dc --- /dev/null +++ b/plans/menudet-m5-m6-signoff.md @@ -0,0 +1,116 @@ +# M5/M6 — logical arrays and native-required graph integration + +Reference: NumPy 2.5.3. Local platform: macOS arm64. Date: 2026-10-09. + +## Implemented acceptance subset + +M5 supplies a versioned native logical-array descriptor/scheduler with checked +allocation bounds, signed strides, byte order, broadcasting (including 0-D and +empty arrays), caller-owned C-order output, disjoint-output enforcement, bounded +tile gathers and an aligned contiguous zero-copy path. Descriptor shape queries +precede output allocation. Native metadata-only reshape, transpose and basic +slice APIs preserve borrowed ownership and reject invalid geometry. + +Six logical reductions support normalized selected axes, keepdims, accumulator +dtype, initial values, participating broadcast masks, empty identities/errors, +modular integer accumulation and tile-independent serial floating grouping. +They remain distinct from persisted explicit block-scalar recipes. Mean/variance, +arg/cumulative operations, general indexing and mutable views are deferred. + +M6 supplies an explicit `_require_native=True` LazyExpr path: eligible safe graphs +lower to cached immutable portable 1.1 plans, arithmetic/functions fuse, and the +native scheduler owns logical traversal/reduction. Python performs metadata and +storage reads, not numerical fallback. Plans key source/signatures/captures and +never retain operand results. Mutation/repeated execution, basic partial reads, +standalone artifact deployment, root reductions and safe portable persistence are +tested. Table row/partition selection, nested lazy/proxy/remote operands, aliases, +reduction partial reads and acceleration overrides reject before writes. + +The useful subset runs with NumExpr import deliberately unavailable, covering +construction, metadata, native-required evaluation/reduction, artifact export/import +and safe persisted recipe reload. Tests also fail on calls to NumExpr/Python graph +evaluation. NumExpr's packaging requirement and default backend selection remain +unchanged: optional packaging for every route needs a wider clean-install audit. + +Detailed native API/ownership/accuracy/divergence contract: +`../miniexpr/doc/native-arrays-1.1.md`. Python reference: +`doc/reference/portable_dsl.rst`. Standalone C deployment/regression host: +`../miniexpr/tests/numpy-compat/arrays.c`. + +## Validation + +- **408 array tests + 9 native graph tests pass.** The numerical matrix spans + all eleven numeric dtypes, six reductions, five axis choices, keepdims and three + tile sizes. Layout tests include C/F, reversed, stepped, endian-swapped and + unaligned arrays. Tests cover bounds rejection, normalization reporting, + masked exceptional values, zero-copy, initial/empty behavior and modular sums. +- Full Python integration checkpoint: **12,703 passed, 55 skipped**. +- Complete native checkpoint: **426 passed**. +- Native C host, shared corpora and examples: **10 sanitizer checks** and + **10 standalone Node/WASM checks passed**. The WASM build's new 32-bit stride + comparison warning was corrected and final rebuilds emitted no new warnings. +- Native interpreter fallback remains explicit: no eligible portable SIMD/JIT + implementation is claimed. Cython calls release the GIL around native scheduling; + this is not free-threaded-build or same-storage mutation qualification. +- Floating serial sums meet a seeded standard forward-error bound against + `math.fsum` and retain bytes across tile sizes. Universal NumPy pairwise bit + equality is deliberately not the reduction contract. + +## Performance evidence and boundaries + +`tools/menudet_graph_bench.py` records isolated subprocess comparisons; +`plans/menudet-m6-benchmarks.json` contains 120 affine baseline rows over tiny +(8-element) and large (262,144-element) float32/float64/int64 arrays, C/strided +layouts, scalar broadcasting and reductions. Routes are direct native-array API, +native-required graph, NumPy, one-thread NumExpr and existing Blosc2. Subprocess +order alternates; compilation, setup, first evaluation, five-run warm median, +thread count, iterator buffer size and process peak RSS are distinct. +Supplemental isolated measurements cover mixed types, partial reads, compressed +operands, persisted portable recipes and four independent concurrent native calls. +Persisted recipes retain their existing block scheduler; they are not relabeled as +native logical-array scheduling. + +For large C-order affine arrays, observed direct/integrated warm medians are about +**495–520 ms**, versus **0.039–0.230 ms** for NumPy/NumExpr elementwise controls and +**0.47–0.66 ms** for existing Blosc2. Logical sums are similarly about **503–520 ms** +versus **0.071–0.268 ms** for controls. This confirms that frontend integration +adds little to the existing strict interpreter bottleneck; it does **not** establish +a native speedup or performance-release readiness. No universal arbitrary slowdown +threshold was imposed. Workload-specific performance budgets remain a scope/release +decision after this baseline, not a silently assumed agreement. + +Zero-copy/gather/scratch and frontend materialization counts are separate. In this +first graph subset, compressed operands may still materialize in full; end-to-end +bounded-RSS scheduling and comprehensive interpreter allocation bounds remain +unproven. Process RSS includes imports, outputs and reference allocations and must +not be equated with native temporary-buffer size. + +## CI qualification + +Dependency pins remain unchanged. The ordinary Python matrix intentionally still +tests the pinned runtime; newly required capabilities are qualified separately. +`.github/workflows/menudet-paired.yml` builds a selected native checkout against +this Python revision on Linux/macOS/Windows, sets `MENUDET_REQUIRE_ARRAY_RUNTIME=1` +and explicitly selects the shared corpora. It does not hide missing capabilities +behind skips. It uploads exact paired SHAs and native logs. Native branch CI now +also runs on the experimental `numpy-compat` branch. + +Remote qualification results will be recorded after the published branches run. +The previous green Python runs at `cf6f25c` and native main runs are not evidence +for these M5/M6 changes. No release/default acceleration or optional-dependency +packaging claim follows from this implementation checkpoint. + +## Reproduction + +Use the `blosc2` conda environment and explicitly rebuild against the sibling +native checkout. Then: + +```sh +MENUDET_REQUIRE_ARRAY_RUNTIME=1 conda run -n blosc2 pytest \ + tests/test_menudet_arrays.py tests/test_menudet_native_graph.py -q -n 0 +conda run -n blosc2 ctest --test-dir "$NATIVE_BUILD" --output-on-failure +conda run -n blosc2 python -m tools.menudet_graph_bench \ + --report plans/menudet-m6-benchmarks.json +MENUDET_WORK_DIR="$APPROVED_WORK_DIR" conda run -n blosc2 python \ + -m tools.menudet_graph_bench --report plans/menudet-m6-benchmarks.json --supplement-existing +``` diff --git a/plans/menudet-m6-benchmarks.json b/plans/menudet-m6-benchmarks.json new file mode 100644 index 000000000..7c7ffbb3a --- /dev/null +++ b/plans/menudet-m6-benchmarks.json @@ -0,0 +1,3254 @@ +{ + "platform": "macOS-26.6.2-arm64-arm-64bit-Mach-O", + "rows": [ + { + "route": "native", + "size": 8, + "dtype": "float32", + "layout": "C", + "reduction": false, + "compile_ms": 0.514667, + "setup_ms": 0.001792, + "first_ms": 0.058334, + "warm_median_ms": 0.020708, + "peak_rss_bytes": 73596928, + "native_report": { + "temporary_bytes": 0, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 1, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 8, + "dtype": "float32", + "layout": "C", + "reduction": false, + "compile_ms": 0.305833, + "setup_ms": 0.000375, + "first_ms": 0.098125, + "warm_median_ms": 0.053042, + "peak_rss_bytes": 72335360, + "native_report": { + "temporary_bytes": 0, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 1, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 8, + "dtype": "float32", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000375, + "first_ms": 0.007458, + "warm_median_ms": 0.000792, + "peak_rss_bytes": 71942144, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 8, + "dtype": "float32", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.116208, + "first_ms": 0.211833, + "warm_median_ms": 0.005209, + "peak_rss_bytes": 71696384, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 8, + "dtype": "float32", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000292, + "first_ms": 0.795667, + "warm_median_ms": 0.184833, + "peak_rss_bytes": 73629696, + "native_report": null, + "shape": [ + 8 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 8, + "dtype": "float32", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000333, + "first_ms": 0.6895, + "warm_median_ms": 0.206625, + "peak_rss_bytes": 72859648, + "native_report": null, + "shape": [ + 8 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 8, + "dtype": "float32", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.103375, + "first_ms": 0.24625, + "warm_median_ms": 0.005166, + "peak_rss_bytes": 72040448, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 8, + "dtype": "float32", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000292, + "first_ms": 0.013292, + "warm_median_ms": 0.001959, + "peak_rss_bytes": 69795840, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 8, + "dtype": "float32", + "layout": "C", + "reduction": true, + "compile_ms": 0.299958, + "setup_ms": 0.000459, + "first_ms": 0.104625, + "warm_median_ms": 0.061417, + "peak_rss_bytes": 74563584, + "native_report": { + "temporary_bytes": 32, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 1, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 8, + "dtype": "float32", + "layout": "C", + "reduction": true, + "compile_ms": 0.3175, + "setup_ms": 0.001667, + "first_ms": 0.042458, + "warm_median_ms": 0.020625, + "peak_rss_bytes": 74924032, + "native_report": { + "temporary_bytes": 32, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 1, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 8, + "dtype": "float32", + "layout": "strided", + "reduction": false, + "compile_ms": 0.317792, + "setup_ms": 0.001709, + "first_ms": 0.042292, + "warm_median_ms": 0.020417, + "peak_rss_bytes": 71925760, + "native_report": { + "temporary_bytes": 32, + "gathered_bytes": 32, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 8, + "dtype": "float32", + "layout": "strided", + "reduction": false, + "compile_ms": 0.29625, + "setup_ms": 0.000375, + "first_ms": 0.096083, + "warm_median_ms": 0.052083, + "peak_rss_bytes": 75169792, + "native_report": { + "temporary_bytes": 32, + "gathered_bytes": 32, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 8, + "dtype": "float32", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000375, + "first_ms": 0.008542, + "warm_median_ms": 0.001083, + "peak_rss_bytes": 69337088, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 8, + "dtype": "float32", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.117667, + "first_ms": 0.226125, + "warm_median_ms": 0.005125, + "peak_rss_bytes": 71090176, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 8, + "dtype": "float32", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.0005, + "first_ms": 0.668333, + "warm_median_ms": 0.179291, + "peak_rss_bytes": 72744960, + "native_report": null, + "shape": [ + 8 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 8, + "dtype": "float32", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000459, + "first_ms": 0.6855, + "warm_median_ms": 0.199917, + "peak_rss_bytes": 75235328, + "native_report": null, + "shape": [ + 8 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 8, + "dtype": "float32", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.116667, + "first_ms": 0.33775, + "warm_median_ms": 0.005583, + "peak_rss_bytes": 72400896, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 8, + "dtype": "float32", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.0005, + "first_ms": 0.013667, + "warm_median_ms": 0.001792, + "peak_rss_bytes": 72597504, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 8, + "dtype": "float32", + "layout": "strided", + "reduction": true, + "compile_ms": 0.297208, + "setup_ms": 0.000416, + "first_ms": 0.102833, + "warm_median_ms": 0.059334, + "peak_rss_bytes": 74137600, + "native_report": { + "temporary_bytes": 64, + "gathered_bytes": 32, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 8, + "dtype": "float32", + "layout": "strided", + "reduction": true, + "compile_ms": 0.354459, + "setup_ms": 0.002042, + "first_ms": 0.048541, + "warm_median_ms": 0.021125, + "peak_rss_bytes": 72679424, + "native_report": { + "temporary_bytes": 64, + "gathered_bytes": 32, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 8, + "dtype": "float64", + "layout": "C", + "reduction": false, + "compile_ms": 0.333041, + "setup_ms": 0.002, + "first_ms": 0.052083, + "warm_median_ms": 0.023292, + "peak_rss_bytes": 73924608, + "native_report": { + "temporary_bytes": 0, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 1, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 8, + "dtype": "float64", + "layout": "C", + "reduction": false, + "compile_ms": 0.322125, + "setup_ms": 0.000584, + "first_ms": 0.104, + "warm_median_ms": 0.053166, + "peak_rss_bytes": 72433664, + "native_report": { + "temporary_bytes": 0, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 1, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 8, + "dtype": "float64", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000625, + "first_ms": 0.006375, + "warm_median_ms": 0.000792, + "peak_rss_bytes": 71532544, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 8, + "dtype": "float64", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.119042, + "first_ms": 0.221666, + "warm_median_ms": 0.005083, + "peak_rss_bytes": 71843840, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 8, + "dtype": "float64", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000375, + "first_ms": 0.753417, + "warm_median_ms": 0.177916, + "peak_rss_bytes": 73744384, + "native_report": null, + "shape": [ + 8 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 8, + "dtype": "float64", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000333, + "first_ms": 0.696667, + "warm_median_ms": 0.200666, + "peak_rss_bytes": 75415552, + "native_report": null, + "shape": [ + 8 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 8, + "dtype": "float64", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.128084, + "first_ms": 0.335959, + "warm_median_ms": 0.005375, + "peak_rss_bytes": 72630272, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 8, + "dtype": "float64", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000292, + "first_ms": 0.012083, + "warm_median_ms": 0.001917, + "peak_rss_bytes": 71909376, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 8, + "dtype": "float64", + "layout": "C", + "reduction": true, + "compile_ms": 0.300542, + "setup_ms": 0.0005, + "first_ms": 0.104, + "warm_median_ms": 0.058083, + "peak_rss_bytes": 74907648, + "native_report": { + "temporary_bytes": 64, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 1, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 8, + "dtype": "float64", + "layout": "C", + "reduction": true, + "compile_ms": 0.302084, + "setup_ms": 0.001542, + "first_ms": 0.041875, + "warm_median_ms": 0.020625, + "peak_rss_bytes": 75268096, + "native_report": { + "temporary_bytes": 64, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 1, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 8, + "dtype": "float64", + "layout": "strided", + "reduction": false, + "compile_ms": 0.310417, + "setup_ms": 0.001708, + "first_ms": 0.04275, + "warm_median_ms": 0.022084, + "peak_rss_bytes": 73596928, + "native_report": { + "temporary_bytes": 64, + "gathered_bytes": 64, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 8, + "dtype": "float64", + "layout": "strided", + "reduction": false, + "compile_ms": 0.308292, + "setup_ms": 0.000417, + "first_ms": 0.097209, + "warm_median_ms": 0.054542, + "peak_rss_bytes": 73957376, + "native_report": { + "temporary_bytes": 64, + "gathered_bytes": 64, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 8, + "dtype": "float64", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000417, + "first_ms": 0.005917, + "warm_median_ms": 0.000834, + "peak_rss_bytes": 72253440, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 8, + "dtype": "float64", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.11, + "first_ms": 0.277667, + "warm_median_ms": 0.0055, + "peak_rss_bytes": 70238208, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 8, + "dtype": "float64", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000333, + "first_ms": 0.636625, + "warm_median_ms": 0.189333, + "peak_rss_bytes": 75481088, + "native_report": null, + "shape": [ + 8 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 8, + "dtype": "float64", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000417, + "first_ms": 0.765125, + "warm_median_ms": 0.205667, + "peak_rss_bytes": 73285632, + "native_report": null, + "shape": [ + 8 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 8, + "dtype": "float64", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.111459, + "first_ms": 0.237083, + "warm_median_ms": 0.0055, + "peak_rss_bytes": 71139328, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 8, + "dtype": "float64", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000375, + "first_ms": 0.010958, + "warm_median_ms": 0.001875, + "peak_rss_bytes": 69353472, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 8, + "dtype": "float64", + "layout": "strided", + "reduction": true, + "compile_ms": 0.339375, + "setup_ms": 0.000333, + "first_ms": 0.104167, + "warm_median_ms": 0.059708, + "peak_rss_bytes": 74383360, + "native_report": { + "temporary_bytes": 128, + "gathered_bytes": 64, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 8, + "dtype": "float64", + "layout": "strided", + "reduction": true, + "compile_ms": 0.300708, + "setup_ms": 0.001666, + "first_ms": 0.042417, + "warm_median_ms": 0.02025, + "peak_rss_bytes": 71925760, + "native_report": { + "temporary_bytes": 128, + "gathered_bytes": 64, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 8, + "dtype": "int64", + "layout": "C", + "reduction": false, + "compile_ms": 0.3185, + "setup_ms": 0.001459, + "first_ms": 0.042667, + "warm_median_ms": 0.020375, + "peak_rss_bytes": 73121792, + "native_report": { + "temporary_bytes": 0, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 1, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 8, + "dtype": "int64", + "layout": "C", + "reduction": false, + "compile_ms": 0.3195, + "setup_ms": 0.000416, + "first_ms": 0.102833, + "warm_median_ms": 0.056875, + "peak_rss_bytes": 74629120, + "native_report": { + "temporary_bytes": 0, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 1, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 8, + "dtype": "int64", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000417, + "first_ms": 0.008292, + "warm_median_ms": 0.00075, + "peak_rss_bytes": 71516160, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 8, + "dtype": "int64", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.147875, + "first_ms": 0.271542, + "warm_median_ms": 0.005208, + "peak_rss_bytes": 71811072, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 8, + "dtype": "int64", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000459, + "first_ms": 0.641375, + "warm_median_ms": 0.190333, + "peak_rss_bytes": 72859648, + "native_report": null, + "shape": [ + 8 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 8, + "dtype": "int64", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000292, + "first_ms": 0.68525, + "warm_median_ms": 0.19875, + "peak_rss_bytes": 73908224, + "native_report": null, + "shape": [ + 8 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 8, + "dtype": "int64", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.116125, + "first_ms": 0.271375, + "warm_median_ms": 0.005333, + "peak_rss_bytes": 71811072, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 8, + "dtype": "int64", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000375, + "first_ms": 0.014542, + "warm_median_ms": 0.001834, + "peak_rss_bytes": 70991872, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 8, + "dtype": "int64", + "layout": "C", + "reduction": true, + "compile_ms": 0.345291, + "setup_ms": 0.000458, + "first_ms": 0.117834, + "warm_median_ms": 0.068917, + "peak_rss_bytes": 73056256, + "native_report": { + "temporary_bytes": 64, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 1, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 8, + "dtype": "int64", + "layout": "C", + "reduction": true, + "compile_ms": 0.303792, + "setup_ms": 0.001666, + "first_ms": 0.044416, + "warm_median_ms": 0.020833, + "peak_rss_bytes": 75038720, + "native_report": { + "temporary_bytes": 64, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 1, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 8, + "dtype": "int64", + "layout": "strided", + "reduction": false, + "compile_ms": 0.301875, + "setup_ms": 0.0015, + "first_ms": 0.042167, + "warm_median_ms": 0.022375, + "peak_rss_bytes": 74301440, + "native_report": { + "temporary_bytes": 64, + "gathered_bytes": 64, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 8, + "dtype": "int64", + "layout": "strided", + "reduction": false, + "compile_ms": 0.301, + "setup_ms": 0.000375, + "first_ms": 0.094584, + "warm_median_ms": 0.056708, + "peak_rss_bytes": 74596352, + "native_report": { + "temporary_bytes": 64, + "gathered_bytes": 64, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 8, + "dtype": "int64", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000458, + "first_ms": 0.007042, + "warm_median_ms": 0.000667, + "peak_rss_bytes": 71745536, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 8, + "dtype": "int64", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.120041, + "first_ms": 0.287167, + "warm_median_ms": 0.005125, + "peak_rss_bytes": 72531968, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 8, + "dtype": "int64", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000416, + "first_ms": 0.651542, + "warm_median_ms": 0.189166, + "peak_rss_bytes": 71974912, + "native_report": null, + "shape": [ + 8 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 8, + "dtype": "int64", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000417, + "first_ms": 0.711209, + "warm_median_ms": 0.204458, + "peak_rss_bytes": 72941568, + "native_report": null, + "shape": [ + 8 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 8, + "dtype": "int64", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.127584, + "first_ms": 0.298583, + "warm_median_ms": 0.005417, + "peak_rss_bytes": 71122944, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 8, + "dtype": "int64", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000541, + "first_ms": 0.016125, + "warm_median_ms": 0.002084, + "peak_rss_bytes": 72450048, + "native_report": null, + "shape": [ + 8 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 8, + "dtype": "int64", + "layout": "strided", + "reduction": true, + "compile_ms": 0.303917, + "setup_ms": 0.000583, + "first_ms": 0.102917, + "warm_median_ms": 0.060042, + "peak_rss_bytes": 72384512, + "native_report": { + "temporary_bytes": 128, + "gathered_bytes": 64, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 8, + "dtype": "int64", + "layout": "strided", + "reduction": true, + "compile_ms": 0.303958, + "setup_ms": 0.001584, + "first_ms": 0.043, + "warm_median_ms": 0.02075, + "peak_rss_bytes": 73269248, + "native_report": { + "temporary_bytes": 128, + "gathered_bytes": 64, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 8 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 262144, + "dtype": "float32", + "layout": "C", + "reduction": false, + "compile_ms": 0.294166, + "setup_ms": 0.001541, + "first_ms": 492.981041, + "warm_median_ms": 495.235625, + "peak_rss_bytes": 86245376, + "native_report": { + "temporary_bytes": 0, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 256, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 262144, + "dtype": "float32", + "layout": "C", + "reduction": false, + "compile_ms": 0.3205, + "setup_ms": 0.000459, + "first_ms": 495.281333, + "warm_median_ms": 496.517792, + "peak_rss_bytes": 85737472, + "native_report": { + "temporary_bytes": 0, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 256, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 262144, + "dtype": "float32", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000458, + "first_ms": 0.153667, + "warm_median_ms": 0.039084, + "peak_rss_bytes": 78987264, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 262144, + "dtype": "float32", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.100291, + "first_ms": 0.469125, + "warm_median_ms": 0.137917, + "peak_rss_bytes": 83214336, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 262144, + "dtype": "float32", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000375, + "first_ms": 0.903542, + "warm_median_ms": 0.468625, + "peak_rss_bytes": 87605248, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 262144, + "dtype": "float32", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000417, + "first_ms": 0.976458, + "warm_median_ms": 0.518292, + "peak_rss_bytes": 77824000, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 262144, + "dtype": "float32", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.119917, + "first_ms": 0.601167, + "warm_median_ms": 0.268375, + "peak_rss_bytes": 75677696, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 262144, + "dtype": "float32", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000833, + "first_ms": 0.178166, + "warm_median_ms": 0.07125, + "peak_rss_bytes": 76070912, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 262144, + "dtype": "float32", + "layout": "C", + "reduction": true, + "compile_ms": 0.294875, + "setup_ms": 0.000458, + "first_ms": 497.676542, + "warm_median_ms": 502.578083, + "peak_rss_bytes": 77299712, + "native_report": { + "temporary_bytes": 4096, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 256, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 262144, + "dtype": "float32", + "layout": "C", + "reduction": true, + "compile_ms": 0.30275, + "setup_ms": 0.001625, + "first_ms": 502.72525, + "warm_median_ms": 502.689958, + "peak_rss_bytes": 77971456, + "native_report": { + "temporary_bytes": 4096, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 256, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 262144, + "dtype": "float32", + "layout": "strided", + "reduction": false, + "compile_ms": 0.334625, + "setup_ms": 0.001875, + "first_ms": 499.394834, + "warm_median_ms": 501.993584, + "peak_rss_bytes": 87572480, + "native_report": { + "temporary_bytes": 4096, + "gathered_bytes": 1048576, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 262144, + "dtype": "float32", + "layout": "strided", + "reduction": false, + "compile_ms": 0.301375, + "setup_ms": 0.000416, + "first_ms": 497.764541, + "warm_median_ms": 500.992625, + "peak_rss_bytes": 86851584, + "native_report": { + "temporary_bytes": 4096, + "gathered_bytes": 1048576, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 262144, + "dtype": "float32", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000333, + "first_ms": 0.131583, + "warm_median_ms": 0.076208, + "peak_rss_bytes": 81608704, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 262144, + "dtype": "float32", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.133416, + "first_ms": 0.5, + "warm_median_ms": 0.13775, + "peak_rss_bytes": 83869696, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 262144, + "dtype": "float32", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000458, + "first_ms": 0.920667, + "warm_median_ms": 0.540459, + "peak_rss_bytes": 91881472, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 262144, + "dtype": "float32", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.0005, + "first_ms": 0.955708, + "warm_median_ms": 0.448208, + "peak_rss_bytes": 78233600, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 262144, + "dtype": "float32", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.137083, + "first_ms": 0.528041, + "warm_median_ms": 0.267208, + "peak_rss_bytes": 76300288, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 262144, + "dtype": "float32", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000542, + "first_ms": 0.179875, + "warm_median_ms": 0.113792, + "peak_rss_bytes": 76333056, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 262144, + "dtype": "float32", + "layout": "strided", + "reduction": true, + "compile_ms": 0.317667, + "setup_ms": 0.000417, + "first_ms": 500.38925, + "warm_median_ms": 501.741583, + "peak_rss_bytes": 77103104, + "native_report": { + "temporary_bytes": 8192, + "gathered_bytes": 1048576, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 262144, + "dtype": "float32", + "layout": "strided", + "reduction": true, + "compile_ms": 0.302459, + "setup_ms": 0.001708, + "first_ms": 508.356958, + "warm_median_ms": 511.460667, + "peak_rss_bytes": 78151680, + "native_report": { + "temporary_bytes": 8192, + "gathered_bytes": 1048576, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 262144, + "dtype": "float64", + "layout": "C", + "reduction": false, + "compile_ms": 0.317667, + "setup_ms": 0.001542, + "first_ms": 501.392292, + "warm_median_ms": 506.269625, + "peak_rss_bytes": 93011968, + "native_report": { + "temporary_bytes": 0, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 256, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 262144, + "dtype": "float64", + "layout": "C", + "reduction": false, + "compile_ms": 0.298208, + "setup_ms": 0.000333, + "first_ms": 503.746333, + "warm_median_ms": 502.782708, + "peak_rss_bytes": 91258880, + "native_report": { + "temporary_bytes": 0, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 256, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 262144, + "dtype": "float64", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000417, + "first_ms": 0.228375, + "warm_median_ms": 0.137167, + "peak_rss_bytes": 88227840, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 262144, + "dtype": "float64", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.127, + "first_ms": 0.480667, + "warm_median_ms": 0.230459, + "peak_rss_bytes": 88981504, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 262144, + "dtype": "float64", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000417, + "first_ms": 1.053334, + "warm_median_ms": 0.655667, + "peak_rss_bytes": 98516992, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 262144, + "dtype": "float64", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000542, + "first_ms": 1.059792, + "warm_median_ms": 0.545542, + "peak_rss_bytes": 81281024, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 262144, + "dtype": "float64", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.130041, + "first_ms": 0.593542, + "warm_median_ms": 0.267958, + "peak_rss_bytes": 76365824, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 262144, + "dtype": "float64", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000792, + "first_ms": 0.315459, + "warm_median_ms": 0.136792, + "peak_rss_bytes": 77398016, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 262144, + "dtype": "float64", + "layout": "C", + "reduction": true, + "compile_ms": 0.342917, + "setup_ms": 0.0005, + "first_ms": 530.502166, + "warm_median_ms": 505.585417, + "peak_rss_bytes": 78807040, + "native_report": { + "temporary_bytes": 8192, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 256, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 262144, + "dtype": "float64", + "layout": "C", + "reduction": true, + "compile_ms": 0.309167, + "setup_ms": 0.001458, + "first_ms": 505.576, + "warm_median_ms": 506.144167, + "peak_rss_bytes": 77611008, + "native_report": { + "temporary_bytes": 8192, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 256, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 262144, + "dtype": "float64", + "layout": "strided", + "reduction": false, + "compile_ms": 0.300125, + "setup_ms": 0.001542, + "first_ms": 506.595042, + "warm_median_ms": 504.319083, + "peak_rss_bytes": 96993280, + "native_report": { + "temporary_bytes": 8192, + "gathered_bytes": 2097152, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 262144, + "dtype": "float64", + "layout": "strided", + "reduction": false, + "compile_ms": 0.322625, + "setup_ms": 0.0005, + "first_ms": 508.51675, + "warm_median_ms": 509.339458, + "peak_rss_bytes": 95666176, + "native_report": { + "temporary_bytes": 8192, + "gathered_bytes": 2097152, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 262144, + "dtype": "float64", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.001792, + "first_ms": 0.24225, + "warm_median_ms": 0.147166, + "peak_rss_bytes": 88637440, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 262144, + "dtype": "float64", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.171959, + "first_ms": 0.46425, + "warm_median_ms": 0.251958, + "peak_rss_bytes": 91258880, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 262144, + "dtype": "float64", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.0005, + "first_ms": 1.035583, + "warm_median_ms": 0.646959, + "peak_rss_bytes": 104890368, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 262144, + "dtype": "float64", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000375, + "first_ms": 1.089417, + "warm_median_ms": 0.624208, + "peak_rss_bytes": 83738624, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 262144, + "dtype": "float64", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.121584, + "first_ms": 0.548375, + "warm_median_ms": 0.274, + "peak_rss_bytes": 81248256, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 262144, + "dtype": "float64", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000417, + "first_ms": 0.27425, + "warm_median_ms": 0.183958, + "peak_rss_bytes": 77643776, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 262144, + "dtype": "float64", + "layout": "strided", + "reduction": true, + "compile_ms": 0.31675, + "setup_ms": 0.000375, + "first_ms": 507.456167, + "warm_median_ms": 509.784708, + "peak_rss_bytes": 82690048, + "native_report": { + "temporary_bytes": 16384, + "gathered_bytes": 2097152, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 262144, + "dtype": "float64", + "layout": "strided", + "reduction": true, + "compile_ms": 0.307458, + "setup_ms": 0.001708, + "first_ms": 507.66325, + "warm_median_ms": 509.10025, + "peak_rss_bytes": 81035264, + "native_report": { + "temporary_bytes": 16384, + "gathered_bytes": 2097152, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 262144, + "dtype": "int64", + "layout": "C", + "reduction": false, + "compile_ms": 0.326041, + "setup_ms": 0.001709, + "first_ms": 511.636792, + "warm_median_ms": 519.098875, + "peak_rss_bytes": 96763904, + "native_report": { + "temporary_bytes": 0, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 256, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 262144, + "dtype": "int64", + "layout": "C", + "reduction": false, + "compile_ms": 0.329458, + "setup_ms": 0.000542, + "first_ms": 509.748875, + "warm_median_ms": 511.0815, + "peak_rss_bytes": 94715904, + "native_report": { + "temporary_bytes": 0, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 256, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 262144, + "dtype": "int64", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000667, + "first_ms": 0.235166, + "warm_median_ms": 0.160625, + "peak_rss_bytes": 88162304, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 262144, + "dtype": "int64", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.1445, + "first_ms": 0.557083, + "warm_median_ms": 0.189042, + "peak_rss_bytes": 92995584, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 262144, + "dtype": "int64", + "layout": "C", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000334, + "first_ms": 1.014875, + "warm_median_ms": 0.640917, + "peak_rss_bytes": 98385920, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 262144, + "dtype": "int64", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000333, + "first_ms": 1.018042, + "warm_median_ms": 0.544291, + "peak_rss_bytes": 80887808, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 262144, + "dtype": "int64", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.124084, + "first_ms": 0.438125, + "warm_median_ms": 0.210834, + "peak_rss_bytes": 76611584, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 262144, + "dtype": "int64", + "layout": "C", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.000458, + "first_ms": 0.252916, + "warm_median_ms": 0.163167, + "peak_rss_bytes": 74317824, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 262144, + "dtype": "int64", + "layout": "C", + "reduction": true, + "compile_ms": 0.309125, + "setup_ms": 0.000458, + "first_ms": 514.61025, + "warm_median_ms": 516.72075, + "peak_rss_bytes": 76988416, + "native_report": { + "temporary_bytes": 8192, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 256, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 262144, + "dtype": "int64", + "layout": "C", + "reduction": true, + "compile_ms": 0.307667, + "setup_ms": 0.001666, + "first_ms": 516.029709, + "warm_median_ms": 520.246375, + "peak_rss_bytes": 78872576, + "native_report": { + "temporary_bytes": 8192, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 256, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 262144, + "dtype": "int64", + "layout": "strided", + "reduction": false, + "compile_ms": 0.313375, + "setup_ms": 0.001917, + "first_ms": 511.699, + "warm_median_ms": 515.242542, + "peak_rss_bytes": 97337344, + "native_report": { + "temporary_bytes": 8192, + "gathered_bytes": 2097152, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 262144, + "dtype": "int64", + "layout": "strided", + "reduction": false, + "compile_ms": 0.306833, + "setup_ms": 0.0005, + "first_ms": 516.132209, + "warm_median_ms": 518.433833, + "peak_rss_bytes": 99778560, + "native_report": { + "temporary_bytes": 8192, + "gathered_bytes": 2097152, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 262144, + "dtype": "int64", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000583, + "first_ms": 0.257334, + "warm_median_ms": 0.175792, + "peak_rss_bytes": 90587136, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 262144, + "dtype": "int64", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.11375, + "first_ms": 0.439167, + "warm_median_ms": 0.224459, + "peak_rss_bytes": 90357760, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 262144, + "dtype": "int64", + "layout": "strided", + "reduction": false, + "compile_ms": null, + "setup_ms": 0.000459, + "first_ms": 0.95875, + "warm_median_ms": 0.512791, + "peak_rss_bytes": 97435648, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "blosc2", + "size": 262144, + "dtype": "int64", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.0005, + "first_ms": 1.135, + "warm_median_ms": 0.490584, + "peak_rss_bytes": 83738624, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "blosc2", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numexpr", + "size": 262144, + "dtype": "int64", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.127916, + "first_ms": 0.489, + "warm_median_ms": 0.207166, + "peak_rss_bytes": 83050496, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numexpr", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "numpy", + "size": 262144, + "dtype": "int64", + "layout": "strided", + "reduction": true, + "compile_ms": null, + "setup_ms": 0.001, + "first_ms": 0.287667, + "warm_median_ms": 0.186917, + "peak_rss_bytes": 80494592, + "native_report": null, + "shape": [ + 262144 + ], + "backend": "numpy", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "graph", + "size": 262144, + "dtype": "int64", + "layout": "strided", + "reduction": true, + "compile_ms": 0.317375, + "setup_ms": 0.000584, + "first_ms": 518.431334, + "warm_median_ms": 516.006375, + "peak_rss_bytes": 81428480, + "native_report": { + "temporary_bytes": 16384, + "gathered_bytes": 2097152, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + }, + { + "route": "native", + "size": 262144, + "dtype": "int64", + "layout": "strided", + "reduction": true, + "compile_ms": 0.302167, + "setup_ms": 0.001542, + "first_ms": 520.158167, + "warm_median_ms": 520.628917, + "peak_rss_bytes": 83558400, + "native_report": { + "temporary_bytes": 16384, + "gathered_bytes": 2097152, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 256, + "fp_flags": 0, + "fp_supported": true + }, + "shape": [ + 262144 + ], + "backend": "portable-interpreter", + "threads": 1, + "iterator_tile_items": 1024, + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py" + } + ], + "limitations": [ + "Process peak RSS includes interpreter/imports/reference allocations.", + "One serial native thread; compressed input frontend not timed in this matrix.", + "Compilation measured for native plan; control-route parsing is included in first run.", + "No universal speed budget or speedup claim." + ], + "supplemental": [ + { + "scenario": "mixed", + "compile_ms": 0.301708, + "first_ms": 8.51275, + "warm_median_ms": 8.702083, + "load_ms": null, + "size": 8192, + "threads": 1, + "peak_rss_bytes": 74825728, + "native_report": { + "temporary_bytes": 8192, + "gathered_bytes": 65536, + "normalization_bytes": 0, + "zero_copy_tiles": 8, + "evaluated_tiles": 8, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "extension_sha256": "f89a36db2b86de2c0a02d2f6a0f2211a543affda4f932b025856d1b043659633", + "python_revision": "cf6f25c1020c13864413e97b39e466c893b77a7b", + "note": "Native logical scheduler" + }, + { + "scenario": "partial", + "compile_ms": 0.337542, + "first_ms": 2.033958, + "warm_median_ms": 1.9575, + "load_ms": null, + "size": 8192, + "threads": 1, + "peak_rss_bytes": 74694656, + "native_report": { + "temporary_bytes": 7680, + "gathered_bytes": 7680, + "normalization_bytes": 0, + "zero_copy_tiles": 0, + "evaluated_tiles": 1, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 0 + }, + "extension_sha256": "f89a36db2b86de2c0a02d2f6a0f2211a543affda4f932b025856d1b043659633", + "python_revision": "cf6f25c1020c13864413e97b39e466c893b77a7b", + "note": "Native logical scheduler" + }, + { + "scenario": "compressed", + "compile_ms": 0.329625, + "first_ms": 16.657417, + "warm_median_ms": 16.510542, + "load_ms": null, + "size": 8192, + "threads": 1, + "peak_rss_bytes": 77463552, + "native_report": { + "temporary_bytes": 0, + "gathered_bytes": 0, + "normalization_bytes": 0, + "zero_copy_tiles": 8, + "evaluated_tiles": 8, + "fp_flags": 0, + "fp_supported": true, + "semantic_revision": "menudet-numpy-1.1", + "backend": "portable-interpreter", + "plan_cache": { + "hits": 6, + "misses": 1, + "maxsize": 128, + "currsize": 1 + }, + "input_materialization_bytes": 65536 + }, + "extension_sha256": "f89a36db2b86de2c0a02d2f6a0f2211a543affda4f932b025856d1b043659633", + "python_revision": "cf6f25c1020c13864413e97b39e466c893b77a7b", + "note": "Native logical scheduler" + }, + { + "scenario": "persisted", + "compile_ms": 0.292458, + "first_ms": 19.385959, + "warm_median_ms": 16.315916, + "load_ms": 0.283959, + "size": 8192, + "threads": 1, + "peak_rss_bytes": 79446016, + "native_report": null, + "extension_sha256": "f89a36db2b86de2c0a02d2f6a0f2211a543affda4f932b025856d1b043659633", + "python_revision": "cf6f25c1020c13864413e97b39e466c893b77a7b", + "note": "Existing portable recipe block scheduler" + }, + { + "scenario": "threaded", + "compile_ms": 0.305041, + "first_ms": 16.927917, + "warm_median_ms": 17.332875, + "load_ms": null, + "size": 8192, + "threads": 4, + "peak_rss_bytes": 77135872, + "native_report": null, + "extension_sha256": "f89a36db2b86de2c0a02d2f6a0f2211a543affda4f932b025856d1b043659633", + "python_revision": "cf6f25c1020c13864413e97b39e466c893b77a7b", + "note": "Four independent concurrent calls" + } + ] +} diff --git a/plans/menudet-m7-scope-review.md b/plans/menudet-m7-scope-review.md new file mode 100644 index 000000000..8b695db19 --- /dev/null +++ b/plans/menudet-m7-scope-review.md @@ -0,0 +1,151 @@ +# M7 — release scope review + +Date: 2026-10-09. Status: **review started; semantic/release freeze not approved**. +This is a scope proposal and gap review, not release qualification. NumPy **2.5.3** +remains the semantic reference; NumPy 1.26 is a separate host-support target. + +## Revision and evidence boundary + +- Python baseline: `6c863eba` (expanded lowering qualification). +- Native qualification baseline: `2567eb6` (expanded lowering and bulk corpus runner). +- Native HEAD at review: `25a4aa4`, following `3e488a3` (additional operators, + functions/predicates and ND-context lowering). +- The baseline evidence records 429 native passes, 198 focused actual-JIT Python + passes before the bulk refactor, and 12,878 Python passes / 78 skips at the + preceding full-suite checkpoint. These are distinct runs, not a single paired + full-suite qualification at native HEAD. +- The bulk qualification retains all 3,193 arithmetic and 1,154 function cases, + including native-contract diagnostics/divergences. Passing all cases is not a + claim that every case matches NumPy numerically or executes compiled code. +- Later native commits need their own exact-revision qualification. Neither local + baseline success nor older remote green jobs qualifies them automatically. + +Evidence: `menudet-m3-signoff.md`, `menudet-m4-signoff.md`, +`menudet-m5-m6-signoff.md`, `menudet-jit-expanded-lowering.md`, and their JSON reports. +CI diagnosis is recorded in `menudet-ci-qualification.md`. Local fixes to native +`25a4aa4` address Linux libm linkage, Windows builtin identity/remainder handling +and WASM fixture embedding. The patched tree passed 430 native, 63 standalone +WASM and 483 explicit-pair Python tests with zero Python skips. This is additional +working-tree evidence, not clean-SHA or remote Linux/Windows qualification. Fixes +are unpublished; final exact-revision paired CI remains a release gate. + +## Proposed first-release promise + +Release a **declared portable numerical subset**, not full NumPy compatibility: + +1. Opt-in schema/language **1.1 / 1.1**, explicit scalar categories and fixed-width + types; preserve checked **1.0 / 1.0** behavior and reject incompatible version + pairs. Product release numbering is separate from artifact version numbering. +2. Bool, signed/unsigned 8/16/32/64-bit integers and float32/64, with the native + arithmetic/casting matrix, metadata-only inference and documented divergences. +3. The enumerated real-function signatures and per-call native floating-status + contract, with class-aware/exact/sampled-ULP policies rather than global libm + accuracy or NumPy warning/callback parity. +4. Native logical arrays: broadcasting, checked signed-stride/endian descriptors, + bounded iterator gathers, restricted disjoint output, metadata shape operations, + and six axis reductions (`sum`, `prod`, `min`, `max`, `any`, `all`). +5. Explicit native-required eligible LazyExpr graphs, immutable plan reuse, + elementwise artifact deployment and existing safe portable persistence rules. + Unsupported graph capabilities reject; no silent Python numerical fallback. +6. Optional host JIT for explicitly qualified signatures/configurations. Report + actual compilation; unsupported kernels retain the native interpreter. No + universal speedup, explicit portable SIMD, or WASM host-pointer JIT promise. + +Keep existing backend defaults, packaging requirements and dependency pins unchanged +through review. Adoption/pinning for a distributable release is an explicit later +decision, after paired qualification; sibling-checkout development is not shipping +support for the currently pinned dependency. + +## Divergence disposition + +Stable D01–D16 IDs originate in +`../miniexpr/doc/numpy-compat-checkpoint.md`. That document and +`../miniexpr/tests/numpy-compat/inventory.json` are checkpoint evidence, not a current +release matrix. The proposed dispositions below must be consolidated into the +native-owned release register with exact signature/case/evidence links before freeze. + +| ID | Current position / proposal | Release disposition | +| --- | --- | --- | +| D01 fixed-width arithmetic | Modular numeric array arithmetic implemented; checked historical profile unchanged. | Close implementation gap; qualify all promised platforms. | +| D02 weak floating scalars | Float kind/strength promotion implemented in 1.1. | Close implementation gap; retain corpus/persistence checks. | +| D03 signed/unsigned 64-bit | Arithmetic promotes to float64; integer comparisons use exact sign/magnitude rules. | Document exact comparison policy separately from arithmetic/NumPy promotion. | +| D04 Boolean arithmetic | Operator-specific bool rules implemented. | Close implementation gap for the enumerated matrix only. | +| D05 exceptional integer division | Zero/signed-minimum value rules implemented; no synthesized NumPy floating warnings. | Accept documented diagnostics divergence. | +| D06 large/negative shifts | Defined checked-integer results without invalid C shifts. | Close implementation gap; qualify compiled routes separately. | +| D07 narrowing/cast policies | Modular array casts and safe/same_kind/unsafe output matrix implemented; weak construction remains checked. | Close declared conversion gap; no blanket `astype` API parity. | +| D08 float-to-integer failures | Nonfinite/out-of-range truncations reject instead of host-specific NumPy sentinel integers. | Accept deliberate portable divergence. | +| D09 scalar categories | Weak captures, typed scalars and strong 0-D inputs encoded and persisted. Weak-only integers have int64 transport limits. | Close category gap; defer arbitrary-precision arithmetic. | +| D10 half/complex/extended types | Unsupported; some otherwise familiar real-function signatures require float16 and reject. | Defer explicitly; do not widen silently. | +| D11 real functions | 75 spellings / 825 signature rows; native extensions distinguished from NumPy references. | Freeze enumerated subset after platform qualification; defer listed missing spellings/arities. | +| D12 broadcasting | Native logical descriptor API supports scalar/0-D/singleton/empty domains. Legacy flat/block APIs remain separate. | Close native logical-array gap, not every adapter/API shape restriction. | +| D13 axis reductions | Six logical reductions implemented with explicit widths, serial logical-C grouping and masks. | Accept grouping/default-width divergence; defer other reductions. | +| D14 layout/aliasing | Bounded native gathers and direct tiles; foreign-owner Python adapters may copy; outputs must be disjoint. | Accept storage divergence; no mutable-view/in-place parity claim. | +| D15 FP diagnostics | Per-call flags/raise masks, caller restoration and selected participation implemented. WASM cannot expose flags. | Accept IEEE-operation policy and WASM capability limitation, not full `np.seterr`. | +| D16 inferred dtype | Native metadata-only inference independent of requested output conversion implemented. | Close declared inference gap; qualify authoring/persistence routes. | + +Additional release-register entries needed: + +| Topic | Proposed contract / disposition | Evidence or gate | +| --- | --- | --- | +| Lazy `where` / short-circuit | Selected-lane evaluation; unselected branches do not raise flags, unlike eager NumPy argument evaluation. | M4 corpus, actual-JIT mask/recovery tests; cross-platform gate remains. | +| Extrema zero ties / NaNs | Deterministic signed-zero ties; no general NaN payload/sign/signaling preservation promise. | M4 native-contract vectors, not mislabeled NumPy parity. | +| Math accuracy | Existing per-case policies and sampled 8-ULP qualification, no uniform global bound/correct rounding claim. | Each release platform must pass; do not enlarge tolerances to hide failures. | +| Floating reductions | Serial logical-C order, tile-invariant grouping; finite sum forward-error criterion, not NumPy pairwise bit parity. | M5 seeded `math.fsum` tests; no global product-error bound. | +| Array accumulator defaults | Explicit int64/uint64 integer defaults remain portable on WASM; not deployment-host `intp`. | Document 32-bit NumPy-default divergence and explicit dtype override. | +| Graph boundaries | Direct numeric operands, eligible fused elementwise graph plus optional root reduction; restrictions reject before writes. | M6 native-required and unsupported-route tests. | +| Persistence | Elementwise exported kernels and existing portable recipes; logical reduction descriptors deploy via array API. | Do not imply logical options are serialized into old block recipes. | +| Threading | Independent buffers/calls supported; scheduler serial; no same-storage mutation synchronization or free-threaded qualification. | Concurrency tests do not establish these broader claims. | +| Memory | Native iterator scratch bounded; compressed frontend inputs may materialize in full. | Defer end-to-end bounded-RSS promise; report copying/materialization explicitly. | +| NumExpr packaging | Useful native subset tested with imports blocked; dependency remains required by packaging. | Clean-install optionality audit is open, not satisfied by blocked-import tests. | +| Full DSL / SIMD | Distinct execution profiles; no inherited NumPy parity from portable qualification. | Exclude from first portable-subset claim unless independently qualified. | + +## Freeze gates and work ordering + +### Must close before a release claim + +- [ ] **CI:** green native and paired Python jobs for exact release-candidate SHAs + on promised Linux/macOS/Windows architectures and standalone 32-bit WASM; + numerical/required-capability failures cannot be hidden by skips. +- [ ] **Build/install:** interpreter-only/optional-feature builds, supported host + NumPy versions including 1.26, release wheels and standalone deployment examples. + Record configurations actually supported rather than implying every compiler/ + backend/architecture cross-product is qualified. +- [ ] **Current matrix/register:** replace or explicitly label historical inventory; + link current signatures, case IDs, deliberate divergences, actual execution routes + and qualification status. Native corpora remain authoritative. +- [ ] **Documentation consistency:** arithmetic/functions docs still say no JIT; + native array docs describe new operator/ND lowering but also retain an older + fallback paragraph; Python docs and baseline reports predate these additions. + Reconcile against source/tests at the selected candidate, preserving historical + reports as historical evidence. +- [ ] **Artifact/API policy:** approve retaining versus explicitly rejecting older + drafts, migration guidance and capability negotiation. Proposed policy retains + current 1.0/1.1 separation; no silent upgrades or identifier reuse. +- [ ] **Performance acceptance:** agree representative workload-specific budgets, + measure integrated paths as well as flat kernels, and publish cold/first/warm, + threading and allocation/RSS boundaries. Fixed-order native benchmark compiler + rankings are not sufficient evidence. +- [ ] **Scope approval:** accept the deliberate divergences and deferred claims + above; publish compatibility/migration notes and standalone C instructions. + +### Explicit decisions, not automatic code-expansion tasks + +- **NumExpr optional packaging:** either complete the clean-install audit or amend + M6 acceptance to ship this first opt-in subset with the existing dependency. + This proposal recommends the latter; the original M6 packaging task remains open + until that scope change is approved. +- **Compressed traversal / comprehensive allocation bounds:** defer the broad + bounded-memory claim, rather than pretend native iterator bounds cover frontend + materialization. Any stronger release claim requires separate evidence/work. +- **Acceleration breadth:** do not require every valid kernel to compile. Newly + lowered operators/ND context must nevertheless be tested before advertised as + qualified. Further lowering is not a prerequisite to freezing interpreter scope. +- **Deferred APIs/types:** complex/half/extended floats, arbitrary precision, + mean/variance/std, arg/cumulative operations, advanced indexing, mutable views, + general ufunc/tuple APIs, callbacks/object/string NumPy parity and linear algebra + stay outside this proposed release. + +Recommended order: CI diagnosis and scope review in parallel; reconcile release +matrix/docs; approve packaging/performance boundaries; qualify the exact paired +candidate and distribution builds; then semantic freeze and release. M1–M6 +implementation progress must not be confused with completed M7 release acceptance. diff --git a/plans/menudet-numpy-checkpoint-benchmark.json b/plans/menudet-numpy-checkpoint-benchmark.json new file mode 100644 index 000000000..ae792b32d --- /dev/null +++ b/plans/menudet-numpy-checkpoint-benchmark.json @@ -0,0 +1,174 @@ +{ + "platform": "macOS-26.6.2-arm64-arm-64bit-Mach-O", + "numpy": "2.5.3", + "numexpr": "2.14.2", + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "numexpr_threads": 12, + "samples": 7, + "results": [ + { + "dtype": "float32", + "nitems": 16, + "engine": "portable", + "compile_ns": 18250, + "first_ns": 55500, + "median_ns": 41333, + "backend": "interpreter" + }, + { + "dtype": "float32", + "nitems": 16, + "engine": "numpy", + "compile_ns": null, + "first_ns": 3125, + "median_ns": 875, + "backend": "numpy" + }, + { + "dtype": "float32", + "nitems": 16, + "engine": "numexpr", + "compile_ns": null, + "first_ns": 261083, + "median_ns": 5250, + "backend": "numexpr" + }, + { + "dtype": "float32", + "nitems": 262144, + "engine": "portable", + "compile_ns": 18250, + "first_ns": 507846750, + "median_ns": 503989750, + "backend": "interpreter" + }, + { + "dtype": "float32", + "nitems": 262144, + "engine": "numpy", + "compile_ns": null, + "first_ns": 67083, + "median_ns": 48208, + "backend": "numpy" + }, + { + "dtype": "float32", + "nitems": 262144, + "engine": "numexpr", + "compile_ns": null, + "first_ns": 227583, + "median_ns": 171041, + "backend": "numexpr" + }, + { + "dtype": "float64", + "nitems": 16, + "engine": "portable", + "compile_ns": 14750, + "first_ns": 71041, + "median_ns": 32375, + "backend": "interpreter" + }, + { + "dtype": "float64", + "nitems": 16, + "engine": "numpy", + "compile_ns": null, + "first_ns": 1458, + "median_ns": 750, + "backend": "numpy" + }, + { + "dtype": "float64", + "nitems": 16, + "engine": "numexpr", + "compile_ns": null, + "first_ns": 140458, + "median_ns": 4458, + "backend": "numexpr" + }, + { + "dtype": "float64", + "nitems": 262144, + "engine": "portable", + "compile_ns": 14750, + "first_ns": 512491667, + "median_ns": 505005083, + "backend": "interpreter" + }, + { + "dtype": "float64", + "nitems": 262144, + "engine": "numpy", + "compile_ns": null, + "first_ns": 178416, + "median_ns": 118833, + "backend": "numpy" + }, + { + "dtype": "float64", + "nitems": 262144, + "engine": "numexpr", + "compile_ns": null, + "first_ns": 291167, + "median_ns": 208959, + "backend": "numexpr" + }, + { + "dtype": "int64", + "nitems": 16, + "engine": "portable", + "compile_ns": 18958, + "first_ns": 83542, + "median_ns": 32125, + "backend": "interpreter" + }, + { + "dtype": "int64", + "nitems": 16, + "engine": "numpy", + "compile_ns": null, + "first_ns": 1417, + "median_ns": 667, + "backend": "numpy" + }, + { + "dtype": "int64", + "nitems": 16, + "engine": "numexpr", + "compile_ns": null, + "first_ns": 116083, + "median_ns": 4375, + "backend": "numexpr" + }, + { + "dtype": "int64", + "nitems": 262144, + "engine": "portable", + "compile_ns": 18958, + "first_ns": 505870042, + "median_ns": 503212542, + "backend": "interpreter" + }, + { + "dtype": "int64", + "nitems": 262144, + "engine": "numpy", + "compile_ns": null, + "first_ns": 262334, + "median_ns": 153958, + "backend": "numpy" + }, + { + "dtype": "int64", + "nitems": 262144, + "engine": "numexpr", + "compile_ns": null, + "first_ns": 244958, + "median_ns": 193708, + "backend": "numexpr" + } + ], + "limitations": "Single process, fixed order, allocated output; no RSS or direct-native large-array timing.", + "installed_native_revision": "3418cdce4b5c11e1661c8b6453e3d31d94b0b2b4" +} diff --git a/plans/menudet-numpy-checkpoint-results.json b/plans/menudet-numpy-checkpoint-results.json new file mode 100644 index 000000000..2e1a46db3 --- /dev/null +++ b/plans/menudet-numpy-checkpoint-results.json @@ -0,0 +1,688 @@ +{ + "numpy": "2.5.3", + "package": "/Users/faltet/blosc/python-blosc2/src/blosc2/__init__.py", + "extension": "/Users/faltet/miniforge3/envs/blosc2/lib/python3.14/site-packages/blosc2/blosc2_ext.abi3.so", + "extension_sha256": "18870621a7c477f86af2223a0358046a75fe9829e7d07f7270301f91a9229a1f", + "results": [ + { + "id": "int8-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "int16-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "int32-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "int64-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "uint8-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "uint16-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "uint32-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "uint64-add-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "int64-exact-subtract", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000000000000000000001" + }, + "compile_ns": 10500, + "evaluation_ns": 6306 + }, + { + "id": "int8-multiply-boundary", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "int8-negate-min", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "int64-absolute-min", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "float32-weak-literal", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "000000003f800000" + }, + "compile_ns": 13375, + "evaluation_ns": 7431 + }, + { + "id": "float32-typed-float64-capture", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "41700000100000004008000000000000" + }, + "compile_ns": 12958, + "evaluation_ns": 5487 + }, + { + "id": "int8-typed-int64-capture", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "int64", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000080" + }, + "compile_ns": 10958, + "evaluation_ns": 4243 + }, + { + "id": "float32-zero-dimensional", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "float32", + "shape": [], + "encoding": "raw-be-hex", + "hex": "4b800000" + }, + "compile_ns": 9791, + "evaluation_ns": 4343 + }, + { + "id": "int8-float-literal", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "int8-uint8-promote", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "int16", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00fe0080" + }, + "compile_ns": 10417, + "evaluation_ns": 6695 + }, + { + "id": "int64-uint64-promote", + "status": -3, + "category": "invalid_source", + "native_status": 0, + "message": "invalid_source: unsupported implicit numeric promotion; use an explicit cast", + "backend": "interpreter" + }, + { + "id": "int64-uint64-compare", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "bool", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0101" + }, + "compile_ns": 11000, + "evaluation_ns": 6583 + }, + { + "id": "int64-uint64-compare-rounding", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "bool", + "shape": [ + 1 + ], + "encoding": "raw-be-hex", + "hex": "01" + }, + "compile_ns": 9833, + "evaluation_ns": 5479 + }, + { + "id": "bool-add", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "00000000000000020000000000000001" + }, + "compile_ns": 10000, + "evaluation_ns": 6518 + }, + { + "id": "int64-true-divide", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "c002aaaaaaaaaaab4002aaaaaaaaaaab" + }, + "compile_ns": 9875, + "evaluation_ns": 5360 + }, + { + "id": "int64-floor-divide", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000002fffffffffffffffd" + }, + "compile_ns": 11541, + "evaluation_ns": 5258 + }, + { + "id": "int64-remainder", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "int64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "fffffffffffffffffffffffffffffffe" + }, + "compile_ns": 11500, + "evaluation_ns": 5241 + }, + { + "id": "int64-zero-divide", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "int64-min-divide", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "int8-large-shift", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "float64-cast-int", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "int64", + "shape": [ + 3 + ], + "encoding": "raw-be-hex", + "hex": "0000000000000001ffffffffffffffff0000000000000000" + }, + "compile_ns": 9666, + "evaluation_ns": 3247 + }, + { + "id": "float64-cast-infinity", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "int64-narrow-output", + "status": -5, + "category": "evaluation_error", + "native_status": -5, + "message": "evaluation_error: portable interpreter evaluation failed", + "backend": "interpreter" + }, + { + "id": "float32-cast-float", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "float64", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "3ff40000000000008000000000000000" + }, + "compile_ns": 9125, + "evaluation_ns": 3250 + }, + { + "id": "float32-sin", + "status": 0, + "backend": "interpreter", + "output": { + "dtype": "float32", + "shape": [ + 2 + ], + "encoding": "raw-be-hex", + "hex": "0000000080000000" + }, + "compile_ns": 7250, + "evaluation_ns": 3375 + } + ], + "provenance": { + "python_revision": "063fd8b9a4c65ae75d76080f3497086a8e5a3e9d", + "native_revision": "4e45081889e20e6a3820822a808f92de00fff7e6", + "installed_native_revision": "3418cdce4b5c11e1661c8b6453e3d31d94b0b2b4", + "local_changes": [ + "tools/menudet_numpy_compat.py", + "tests/test_menudet_numpy_compat.py", + "checkpoint reports" + ] + }, + "reference_drift": { + "version_changed": false, + "differences": [] + }, + "native": [ + { + "id": "int8-add-boundary", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 54000, + "evaluation_cpu_ns": 2455 + }, + { + "id": "int16-add-boundary", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 10000, + "evaluation_cpu_ns": 2327 + }, + { + "id": "int32-add-boundary", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 8000, + "evaluation_cpu_ns": 2347 + }, + { + "id": "int64-add-boundary", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 6000, + "evaluation_cpu_ns": 2386 + }, + { + "id": "uint8-add-boundary", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 8000, + "evaluation_cpu_ns": 2495 + }, + { + "id": "uint16-add-boundary", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 19000, + "evaluation_cpu_ns": 2406 + }, + { + "id": "uint32-add-boundary", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 12000, + "evaluation_cpu_ns": 2406 + }, + { + "id": "uint64-add-boundary", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 8000, + "evaluation_cpu_ns": 2386 + }, + { + "id": "int64-exact-subtract", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "00000000000000000000000000000001", + "compile_cpu_ns": 13000, + "evaluation_cpu_ns": 2505 + }, + { + "id": "int8-multiply-boundary", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 10000, + "evaluation_cpu_ns": 2465 + }, + { + "id": "int8-negate-min", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 10000, + "evaluation_cpu_ns": 1337 + }, + { + "id": "int64-absolute-min", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 7000, + "evaluation_cpu_ns": 327 + }, + { + "id": "float32-weak-literal", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "000000003f800000", + "compile_cpu_ns": 12000, + "evaluation_cpu_ns": 4386 + }, + { + "id": "float32-typed-float64-capture", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "41700000100000004008000000000000", + "compile_cpu_ns": 9000, + "evaluation_cpu_ns": 2406 + }, + { + "id": "int8-typed-int64-capture", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "0000000000000080", + "compile_cpu_ns": 8000, + "evaluation_cpu_ns": 1356 + }, + { + "id": "float32-zero-dimensional", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "4b800000", + "compile_cpu_ns": 9000, + "evaluation_cpu_ns": 1337 + }, + { + "id": "int8-float-literal", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 8000, + "evaluation_cpu_ns": 1337 + }, + { + "id": "int8-uint8-promote", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "00fe0080", + "compile_cpu_ns": 8000, + "evaluation_cpu_ns": 2426 + }, + { + "id": "int64-uint64-promote", + "status": -3, + "native_status": 0, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 6000, + "evaluation_cpu_ns": 0 + }, + { + "id": "int64-uint64-compare", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "0101", + "compile_cpu_ns": 8000, + "evaluation_cpu_ns": 2376 + }, + { + "id": "int64-uint64-compare-rounding", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "01", + "compile_cpu_ns": 7000, + "evaluation_cpu_ns": 1337 + }, + { + "id": "bool-add", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "00000000000000020000000000000001", + "compile_cpu_ns": 11000, + "evaluation_cpu_ns": 2406 + }, + { + "id": "int64-true-divide", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "c002aaaaaaaaaaab4002aaaaaaaaaaab", + "compile_cpu_ns": 8000, + "evaluation_cpu_ns": 2406 + }, + { + "id": "int64-floor-divide", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "0000000000000002fffffffffffffffd", + "compile_cpu_ns": 9000, + "evaluation_cpu_ns": 2386 + }, + { + "id": "int64-remainder", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "fffffffffffffffffffffffffffffffe", + "compile_cpu_ns": 8000, + "evaluation_cpu_ns": 2376 + }, + { + "id": "int64-zero-divide", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 7000, + "evaluation_cpu_ns": 1356 + }, + { + "id": "int64-min-divide", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 8000, + "evaluation_cpu_ns": 1257 + }, + { + "id": "int8-large-shift", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 6000, + "evaluation_cpu_ns": 1337 + }, + { + "id": "float64-cast-int", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "0000000000000001ffffffffffffffff0000000000000000", + "compile_cpu_ns": 8000, + "evaluation_cpu_ns": 347 + }, + { + "id": "float64-cast-infinity", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 6000, + "evaluation_cpu_ns": 297 + }, + { + "id": "int64-narrow-output", + "status": -5, + "native_status": -5, + "backend": "interpreter", + "hex": "", + "compile_cpu_ns": 4000, + "evaluation_cpu_ns": 327 + }, + { + "id": "float32-cast-float", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "3ff40000000000008000000000000000", + "compile_cpu_ns": 7000, + "evaluation_cpu_ns": 327 + }, + { + "id": "float32-sin", + "status": 0, + "native_status": 0, + "backend": "interpreter", + "hex": "0000000080000000", + "compile_cpu_ns": 5000, + "evaluation_cpu_ns": 446 + } + ] +} diff --git a/plans/menudet-numpy-checkpoint.md b/plans/menudet-numpy-checkpoint.md new file mode 100644 index 000000000..7dd4c3b3c --- /dev/null +++ b/plans/menudet-numpy-checkpoint.md @@ -0,0 +1,141 @@ +# Menudet NumPy compatibility — first checkpoint results + +2026-10-09. Implements section 13 of `menudet-numpy-compat.md`: inventory, +baseline evidence and a small shared conformance slice, **without arithmetic or +default-backend changes**. This records the original checkpoint; subsequent M1 +sign-off and M2 completion are in `menudet-m1-m2-signoff.md`. + +## Paired revisions and reference + +| Component | Revision / configuration | +| --- | --- | +| Python branch start | `numpy-compat`, `063fd8b9a4c65ae75d76080f3497086a8e5a3e9d` | +| Native branch start | `numpy-compat`, `36770f87e10f1b92bfe0f9f92a7039eba2e976ea` | +| Committed native checkpoint/corpus | `4e45081889e20e6a3820822a808f92de00fff7e6` | +| Installed native dependency | established CMake pin `3418cdce4b5c11e1661c8b6453e3d31d94b0b2b4` | +| NumPy semantic reference | **2.5.3**, confirmed in `blosc2` conda environment | +| Verified host | macOS arm64, little endian, 64-bit intp, Python 3.14.4 | +| Reference policy | fixed explicit dtype widths, `np.errstate(all="ignore")`, exact bit comparisons | + +Rebuilt the editable Python install with default FetchContent configuration in a +fresh build directory, `--no-build-isolation --no-deps`; verified the fetched native +checkout SHA above. No sibling source override or dependency-pin/default changes. +Native runtime sources at the pinned revision and the starting native SHA are +identical (the intervening commits change documentation only). The standalone +runner adds no numerical semantics. Exact extension SHA256/package path, runner +revision and local tooling changes are recorded in +`menudet-numpy-checkpoint-results.json`. This is paired starting-revision-plus-local- +changes evidence; the final Python change is identified by its containing revision. + +Initial target set is Linux/macOS/Windows native 64-bit and WASM 32-bit; this +checkpoint verifies **only the host above**. NumPy 1.26 remains a host compatibility +target, not a second semantic reference. Generation refuses another NumPy version; +running reports secondary-version and value drift without rewriting golden data. + +## What was implemented + +Native repository owns the single reviewed corpus, schema and inventory: + +- `tests/numpy-compat/vectors.json`: **33 vectors**, **14 matching / 19 divergent** + explicit signatures. Both runners agree on status and successful output bits. +- `tests/numpy-compat/schema.json`: versioned, lossless big-endian bytes; dtype, + shape, scalar category, weak literal type and IEEE signed-zero/exceptional bits. +- `tests/numpy-compat/inventory.json`: broader capability matrix, including + unsupported and unverified types, functions, array operations and acceleration. +- `tests/numpy-compat/runner.c`: standalone artifact execution with explicit typed + buffers, repeated execution/diagnostic checks and observed-baseline verification. + CTest runs off/on requests and explicitly reports interpreter selection. +- `doc/numpy-compat-checkpoint.md`: traced dispatch/type/cast rules, divergence + register (impact/cost/decision/evidence), platform defaults and transition policy. + +Python integration adds: + +- `tools/menudet_numpy_compat.py`: pinned reference generation, installed-extension + execution, cross-runner recording, baseline verification, drift detection and + preliminary performance measurements. No source `eval`, sibling-library loading + or independently maintained NumPy arithmetic rules. +- `tests/test_menudet_numpy_compat.py`: bit roundtrips, version guard, shared corpus, + authoring export/typed captures, dtype/shape preservation, NumExpr-call prohibition, + future artifact/language rejection and malformed native-vector regression tests. +- Array inventory probes demonstrate rejection of singleton broadcasting, a scalar + block sum of 15 versus NumPy axis sums [3,12], negative-stride copying-adapter + value agreement and unsupported half/complex dtypes. + +The corpus covers all signed/unsigned integer addition boundaries, multiply, +negate/abs minima, exact >2**53 integers, weak float32 literals, typed captures, +0-D arrays, signed/unsigned promotion/comparison, Boolean addition, true/floor +division and remainder, zero/min divisors, shifts, finite/nonfinite casts, +checked output narrowing and floating signed zero. The nonfinite NumPy integer +sentinel is labelled platform-qualified rather than made a universal contract. + +Known NumPy failures are **classified evidence**, not xfailed tests or arithmetic +fixes. Baseline tests pass by preserving those observations. Matching output +signatures are not proof of inferred/intermediate dtype parity. General tolerance, +ULP policies, reference diagnostics, layout recipes, fuzzing/minimization and +WASM/other-platform vector adapters remain milestone-2 work. + +## Verification + +- Native interpreter-only full CTest: **327 passed**. +- Native corpus with JIT off/on request: both passed, actual backend interpreter. +- ASan + UBSan corpus runner: both off/on requests passed, no reported findings. +- Python default suite after a fresh pinned build: **12,220 passed, 55 skipped**. + No new shared-corpus tests were skipped when explicit + corpus/runner paths were provided. Existing platform/capability skips remain. +- Final focused checkpoint tests: **16 passed**, including malformed vectors + executed against the ASan/UBSan runner and the four array/dtype inventory probes. +- Ruff checks and formatting pass. Native builds introduced no reported warnings. + +Reproduction from this repository, selecting native artifacts explicitly: + +```sh +export MENUDET_NUMPY_CORPUS=/absolute/path/to/miniexpr/tests/numpy-compat/vectors.json +export MENUDET_NUMPY_RUNNER=/absolute/path/to/native-build/tests/numpy_compat_runner +conda run -n blosc2 pytest tests/test_menudet_numpy_compat.py -q -n 0 +conda run -n blosc2 python tools/menudet_numpy_compat.py run "$MENUDET_NUMPY_CORPUS" \ + --native-runner "$MENUDET_NUMPY_RUNNER" \ + --native-revision 4e45081889e20e6a3820822a808f92de00fff7e6 \ + --installed-native-revision 3418cdce4b5c11e1661c8b6453e3d31d94b0b2b4 +``` + +`generate` and `record` deliberately rewrite reviewed vectors; ordinary `run` +never does. `benchmark OUTPUT.json` writes separate performance evidence. + +## Next vertical slice and semantic/artifact handling + +Select **fixed-width add/subtract/multiply, negate and abs**, all integer widths. +Eleven of the nineteen divergent vectors directly motivate this narrowly scoped +slice. Native checked helpers localize the work; implement wrapping through +well-defined unsigned/bit operations, then audit accelerated paths independently. +Division/zero diagnostics, shifts, scalar promotion and casts follow separately. + +Before incompatible arithmetic, require **language 1.1 + artifact schema 1.1** and +a distinct native semantic profile. Do not silently reinterpret checked draft 1.0 +artifacts. Retain old interpretation during transition or explicitly reject old +artifacts; opt-in re-export is migration. Current 1.1 rejection is tested, but the +new profile/version is not implemented or advertised by this checkpoint. This +policy does not require permanent competing arithmetic personalities. + +## Feasibility of the remaining plan + +| Work | Assessment | +| --- | --- | +| Finish conformance machinery | High feasibility; extend the existing shared format/runners incrementally, including inferred-type and diagnostic assertions. Native-host adapters and cross-platform reference qualifications need explicit work. | +| Integer arithmetic/promotion/casts | High feasibility, moderate cost. Checked helpers and typed nodes provide a strong base. Boolean rules, weak float context, signed/unsigned 64-bit promotion and cast policies need operation-specific changes, not just wrapping. | +| Functions and exceptional values | Feasible but substantial verification effort. FP-status aggregation, masked branches, float32 intermediates, platform libm differences and JIT agreement are more difficult than adding function names. | +| Native broadcasting/reductions | Feasible, high architectural cost. Existing block execution is not native NumPy array traversal. Shape/stride ownership, empty dimensions, grouping, masks and accumulator defaults must be designed behind a C API. | +| Graph integration / acceleration | Highest near-term risk. The typed interpreter is semantically useful but currently far too slow for NumPy/NumExpr-class throughput. Eligible JIT/SIMD/fusion and reusable plans require semantic-preserving optimization, not relabelling fallback. | +| 1.0 freeze/release | A useful declared subset is feasible. Full NumPy, complex/half extensions, general indexing and view/aliasing parity should remain outside the initial promise unless measured value justifies their cost. | + +`menudet-numpy-checkpoint-benchmark.json` records an affine expression, float32/64 +and int64, 16 and 262,144 elements, compilation/first/steady timings, NumPy and +NumExpr controls. At the larger size the current integrated interpreter takes +roughly **0.49 seconds**, versus sub-millisecond controls. These are preliminary, +single-process fixed-order timings with allocated outputs and 12 NumExpr threads; +they are not controlled release budgets or universal slowdown ratios. The native +runner also records separate CPU microtimings. Larger direct-native timing, RSS, +thread scaling, graph scheduling and alternating subprocess controls remain work. + +Conclusion: proceed with the integer/revision slice; numerical compatibility is +tractable, but performance and native array orchestration must be explicit go/no-go +checkpoints. Do not infer default-switch readiness from semantic baseline success. diff --git a/plans/menudet-numpy-compat.md b/plans/menudet-numpy-compat.md new file mode 100644 index 000000000..e77ffedf1 --- /dev/null +++ b/plans/menudet-numpy-compat.md @@ -0,0 +1,481 @@ +# Menudet: strong NumPy compatibility implementation plan + +Date: 2026-10-09. Branches: `numpy-compat` in Python-Blosc2 and miniexpr. +Status: **M1–M6 declared-subset implementation substantially complete; release +acceptance incomplete.** Cross-platform CI qualification is in progress and M7 scope +review has started; no semantic freeze, release/default-backend change or expanded +packaging promise has been approved. + +### Current milestone position (2026-10-09) + +| Milestone | Position | Remaining acceptance work | +| --- | --- | --- | +| M1–M2: specification / conformance | Implemented checkpoints and authoritative shared corpora. | Consolidate historical inventory into a current release matrix/register. | +| M3: arithmetic / promotion / casts | Declared eleven-dtype matrix implemented in opt-in 1.1. | Exact-revision cross-platform/build qualification; retain explicit divergences. | +| M4: functions / floating policy | Enumerated real signatures and native per-call status implemented. | Platform/libm qualification; no full `np.seterr` promise. | +| M5: logical arrays | Native descriptors, broadcasting, layouts, shape operations and six reductions implemented. | Platform qualification; comprehensive/end-to-end compressed memory claims remain unproven. | +| M6: graph integration / performance | Native-required subset, plan reuse, persistence and opt-in host JIT implemented. | Integrated performance budgets, clean-install packaging audit or approved deferral, distribution qualification. | +| M7: freeze / release | Scope review started; proposed contract and open decisions recorded. | Approve scope, close CI/build/docs gates, freeze and publish. | + +Current review: `plans/menudet-m7-scope-review.md`. Implementation evidence is in +the M1/M2, M3, M4, M5/M6 and expanded-JIT signoff reports; their dates/revisions +matter. Python `6c863eba` / native `2567eb6` are the expanded-lowering qualification +baseline. Native HEAD at this review is `25a4aa4`, with additional lowering work; +baseline results do not automatically qualify those later commits. CI findings +are recorded in `plans/menudet-ci-qualification.md`: Linux linkage, Windows builtin +identity/remainder and WASM fixture fixes are implemented locally. Patched native +`25a4aa4` with Python `6c863eba` passed 430 native, 63 WASM and 483 explicit-pair +Python tests (zero Python skips). These working-tree results are not clean-SHA or +remote Linux/Windows qualification; the fixes remain unpublished and the current +pair's remote qualification remains open. + +The sections below retain the original acceptance criteria. Proposed M7 deferrals +(including NumExpr optional packaging) do **not** silently mark those criteria +complete. Artifact language/schema 1.1 is distinct from product release numbering; +checked 1.0 artifacts and default routes remain unchanged. + +## 1. Objective and release strategy + +Make miniexpr/Menudet capable of reproducing a useful and progressively broader +subset of NumPy numerical expressions from other programming languages, without +Python in the execution loop. Preserve Menudet's additional programming facilities: +local variables, branches, bounded loops, typed captures and logical coordinates. + +NumPy is the semantic reference. NumExpr is an existing execution backend and a +useful performance comparator, not the authority for promotion or numerical results. +NumExpr itself demonstrates that a useful engine need not reproduce all of NumPy. + +Develop compatibility incrementally. Stop extending the 1.0 scope when an extension's +implementation, performance or maintenance cost outweighs its practical value. +Record the remaining divergences and unsupported operations, freeze the resulting +contract, and release 1.0 with a precise compatibility statement. Full NumPy +compliance is neither a prerequisite nor an implied promise. + +Menudet 1.0 is unreleased. Its existing checked-arithmetic and promotion decisions +may be revised deliberately toward NumPy behavior. We do not need two permanent +arithmetic personalities merely to preserve a draft decision. Separate profiles or +explicit checked operations should be introduced only for a demonstrated use case. + +### Relationship to the safer-LazyExpr experiment + +The safer-LazyExpr experiment is successful in its architectural objective: +validated graphs and explicit dispatch provide an eval-free path for the supported, +tested operations while preserving the existing lazy execution machinery. Its +platform verification is green at `063fd8b9`; see +`plans/safer-lazyexpr-results.md` for the exact evidence and boundaries. + +That is our foundation, not a claim of universal safety, default-switch readiness, +complete native allocation bounds or same-storage read/write synchronization. +The NumPy-compatibility work is a new numerical-semantics project. Earlier plans +that deliberately excluded changes to Menudet arithmetic describe the scope of the +previous experiment; they do not prohibit deliberate draft revisions here. + +Reuse the graph, metadata, persistence, differential-testing and benchmarking +machinery. Preserve ordinary LazyExpr behavior while the new backend is opt-in; +NumPy compatibility of a new mode is not permission to silently change the results +of every existing NumExpr/Blosc2 expression. Default adoption is a separate decision. + +## 2. Compatibility claims and initial scope + +Track compatibility separately for: + +1. **Values:** integer/Boolean exactness and floating numerical agreement. +2. **Types:** input acceptance, promotion, intermediate types and output dtype. +3. **Shapes:** broadcasting, output shape, axes and reduction cardinality. +4. **Exceptional behavior:** NaNs, infinities, signed zero, overflow and errors. +5. **Diagnostics:** native error/status categories and floating exception reporting. +6. **Storage behavior:** layout, copying, views, aliasing and output buffers. +7. **Execution quality:** fusion, memory use, parallel scheduling and performance. + +An operation may match the first five without reproducing NumPy views or allocation +patterns. Do not describe a dtype mismatch as full compatibility merely because +small sample values compare equal. Likewise, a native diagnostic category need not +have NumPy's Python warning class or exact message to be useful in a C host. + +### Reference policy + +- Start with one pinned NumPy 2.x release. Proposed baseline: **2.5.3**, the native + version used in the completed experiment; confirm this in milestone 1. +- Record NumPy version, platform integer width, endianness, Python scalar category + where applicable, floating-error policy and reference-generator revision. +- NumPy 1.26 remains a Python-Blosc2 host compatibility target, not a second + simultaneous definition of Menudet arithmetic. A pinned corpus must not change + its meaning according to whichever NumPy version happens to be installed. +- Run secondary NumPy versions to identify reference drift; do not silently + regenerate golden results or change the declared baseline. +- Specify the interpretation of `int`/`intp` and omitted reduction dtypes on 32-bit + versus 64-bit hosts. Prefer explicit widths in portable artifacts. Decide how + source-platform defaults are resolved rather than inheriting the C compiler's + `long` width or accidentally changing persisted results on WASM. + +### Initial priorities + +Prioritize Boolean, standard signed/unsigned integers, float32 and float64; typed +elementwise operations; promotion/casts; common real functions; broadcasting; and +sum/product/min/max/Boolean reductions. Existing string and control-flow capabilities +remain supported but do not imply NumPy string/object compatibility. + +Initially defer complex arithmetic, object arrays, arbitrary Python callbacks, +arbitrary memory access, structured/object semantics, datetime/timedelta calendars, +generalized ufuncs, linear algebra, advanced indexing and full view/aliasing parity. +Assess float16 and extended-precision floats explicitly as dtype extensions rather +than treating their current absence as accidental test omissions. + +## 3. Cross-repository architecture and ownership + +### miniexpr owns native semantics + +- Normative type, operator, cast, function and exceptional-value rules. +- Validation, type inference, interpreter execution and native diagnostics. +- Artifact representation and semantic capability/version identification. +- JIT/SIMD eligibility and agreement with the interpreter. +- Native conformance runners and tests independent of Python at execution time. + +Initial implementation inventory includes `src/dsl_portable_types.c`, +`src/dsl_portable_expr.c`, `src/dsl_portable.c`, their headers, +`src/dsl_portable_fp.h`, and the full DSL compilation path. Existing native tests +include `tests/test_dsl_portable_types.c`, `test_dsl_portable_validation.c`, +`test_dsl_portable_interp.c` and `test_dsl_portable_checked.c`. Confirm actual +dispatch routes before editing; these are starting points, not an exhaustive map. + +### Python-Blosc2 owns authoring and integration + +- Preserve scalar/type intent when lowering Python authoring or expression graphs. +- Bind arrays, storage and logical partitions without redefining native arithmetic. +- Expose native capabilities and diagnostics through the Python extension. +- Integrate lazy scheduling, reductions, persistence and backend eligibility. +- Generate NumPy reference cases and run differential/integration/performance tests. + +Principal integration points: `expression_graph.py`, `lazyexpr.py`, `dsl_kernel.py`, +`portable_kernel.py`, `portable_lazy.py`, `blosc2_ext.pyx`, `b2objects.py` and CTable +kernel registration. Reuse the existing math-certification scripts where their +reference and comparison policy apply; NumPy parity and mathematical accuracy are +separate measurements. + +### Native array orchestration is a distinct layer + +NumPy broadcasting and axis reductions cannot be provided to a C caller merely by +implementing them in Python's `PortableLazyArray`. Milestone 5 must place the +necessary in-memory traversal/grouping machinery behind a native API, with a clear +boundary between miniexpr and C-Blosc2 where compressed storage is involved. +Kernel semantics must not depend on Python-Blosc2 being installed. + +### Paired revision discipline + +- Record starting SHAs for both branches and the exact native dependency revision + used by every integrated result. Branch names alone are not reproducible pins. +- Land native support first, then the matching bindings/lowering/integration. +- Pin native dependencies through the established build configuration; do not + silently search a sibling checkout or rely on an old locally compiled extension. +- Keep the native corpus authoritative and share/version its schema with Python; + avoid maintaining two independently edited semantic rule sets or golden corpora. +- Changes to ordinary full miniexpr execution, portable Menudet execution and the + Python API must be identified separately, even when they share implementation. + +## 4. Milestone 1 — specification, inventory and baseline + +### Implementation work + +1. Confirm the NumPy reference release and supported target platforms. +2. Trace existing promotion and execution in full miniexpr, portable interpreter, + JIT/SIMD paths and Python bindings. Identify output-dtype-driven computation, + implicit scalar coercion and host-width-dependent defaults. +3. Create a machine-readable capability matrix plus a human-readable summary. +4. Establish baseline examples for arithmetic, casts, scalar/array promotion, + exceptional values, functions, broadcasting and reductions. +5. Create the divergence register described below; seed it with checked overflow, + promotion differences, missing complex/half types, function gaps, block-local + versus axis reductions, and adapter copying/binding restrictions. +6. Record performance baselines before semantics or lowering changes. + +Each matrix row needs an operation/signature, input categories/dtypes, reference +configuration, expected output type/shape, participating backend, test IDs and one +of `matching`, `divergent`, `unsupported` or `unverified`. + +**Acceptance:** current behavior is reproducibly classified; initial 1.0 priorities, +reference version and comparison policies are explicit. No inventory item becomes +supported simply by appearing in a proposed milestone. + +## 5. Milestone 2 — language-independent conformance machinery + +### Portable reference format + +Define a versioned vector format with stable case IDs and: + +- Operation graph or normalized kernel, semantic revision and required capabilities. +- Input names, explicit dtype descriptors, shapes, scalar strength/type and layout. +- Integer values represented losslessly; IEEE float bits encoded losslessly; + signed zeros and exceptional classifications retained. Avoid JSON-number loss. +- Expected output dtype, shape and values, or expected native diagnostic category. +- Exact/bitwise/tolerance comparison policy, with explicit absolute/relative/ULP + thresholds and separate NaN/signed-zero treatment. +- Reference provenance, generation seeds and deliberate divergence annotations. + +Represent scalar-versus-0-D-array distinctions explicitly. Define byte order and +layout recipes so C and Python readers reconstruct identical inputs. NaN payload +preservation should not be inferred from an ordinary equal-NaN comparison. + +### Runners and generation + +1. A pinned Python/NumPy generator emits reviewed vectors; it is development tooling. +2. A native runner executes checked-in vectors without Python/NumPy installed. + Reuse existing native JSON/test infrastructure where practical. +3. A Python runner compares NumPy, native interpreter, eligible JIT paths and + Python-Blosc2 integration on the same case IDs. +4. Add seeded property tests and failure minimization; promote important minimized + failures into stable vectors rather than relying only on random coverage. +5. Record skipped capabilities and actual backend selection. A requested JIT that + falls back successfully is interpreter evidence, not JIT conformance evidence. +6. Verify diagnostic cleanup and repeated execution after failures. + +Keep finite mathematical-reference certification alongside NumPy comparisons. +Agreement with one NumPy/libm build is not proof of mathematical correctness over +all inputs. Do not inflate accuracy tolerances merely to turn a platform green. + +**Acceptance:** the same corpus runs in a standalone native host and Python; reports +identify every mismatch and skip. Include at least one small C example consuming +an artifact and explicit typed buffers with no Python runtime dependency. + +## 6. Milestone 3 — arithmetic, promotion and casts + +Implement in vertical slices: specification, reference vectors, native interpreter, +validation/inference, eligible acceleration, Python lowering and persistence tests. + +### 3A. Fixed-width arithmetic + +- Boolean, signed and unsigned arithmetic and comparisons for supported widths. +- Integer wraparound where NumPy defines fixed-width array arithmetic that way. +- Unary negation and absolute-value boundary cases, including signed minima. +- True division, floor division and remainder, especially negative operands. +- Bitwise operators and shifts, with explicit invalid/large shift-count treatment. +- Integer zero divisors, minimum divided by minus one and other exceptional cases. +- Floating arithmetic with specified intermediate precision and contraction rules. + +Implement signed wraparound through well-defined bit/unsigned operations and +explicit conversion rules, never C signed-overflow undefined behavior. Audit +vectorized/JIT code separately. Numerical wrapping does not remove array bounds, +artifact-validation or resource checks. + +### 3B. Promotion and scalar categories + +- An enumerated mixed-dtype promotion matrix, including signed/unsigned mixtures. +- NumPy 2.x weak scalar behavior versus explicitly typed scalar operands. +- Literals and captures whose values do not fit the selected operand dtype. +- Python scalar, typed scalar and zero-dimensional array differences, represented + as language-independent categories rather than references to Python objects. +- Comparisons and predicates whose promotion differs from arithmetic operations. +- Intermediate types computed from operations and operands, not forced by the + requested output buffer or final result conversion. + +Decide syntax/API and artifact encoding for scalar categories before extending +authoring. Preserve type intent through export/import and across non-Python hosts. + +### 3C. Explicit conversion + +- Widening/narrowing integers, float precision changes and Boolean conversions. +- Float-to-integer truncation, range boundaries, NaNs and infinities. +- Supported cast policies corresponding to NumPy's safe/same-kind/unsafe concepts. +- Out-of-range construction versus array arithmetic versus explicit conversion: + these are different NumPy operations and need separate rules/tests. + +Where NumPy results depend on hardware/compiler details or are not a stable +documented contract, choose a defined behavior or reject and record the divergence. +Do not codify one machine's incidental result as a universal standard. + +**Acceptance:** the declared dtype/operator/cast matrix passes on interpreter and +eligible JIT paths across native platforms and WASM. Promotion agrees with actual +execution and remains metadata-only. Unsupported combinations reject predictably. + +## 7. Milestone 4 — functions and exceptional-value semantics + +Prioritize common arithmetic helpers and real math, then add functions by measured +usefulness. Audit aliases and signatures as well as function availability. + +Test `minimum`/`maximum` separately from `fmin`/`fmax`; rounding variants, sign, +absolute value, `where`, power, logarithms, exponentials, trig/hyperbolic operations, +classification and existing nextafter/copysign-style primitives. + +For each function cover: + +- Accepted input types, promotion and result dtype. +- Finite values, domain boundaries, cancellation and large/small magnitudes. +- NaNs, infinities, positive/negative zero and subnormals. +- Domain, overflow, underflow and divide-by-zero reporting. +- Evaluation of unselected `where` branches and observable diagnostics. +- Float32 evaluation versus computing in float64 and narrowing afterward. +- Interpreter, SIMD and JIT agreement with the declared accuracy policy. + +Design a native floating-status/error policy usable from C and other languages. +Define clearing/aggregation across blocks, masking participation, threading and +restoration of the caller's floating environment. Initially document differences +from `np.seterr` rather than promising its complete Python callback/warning API. + +**Acceptance:** every advertised function has signature and exceptional-value +coverage plus explicit accuracy criteria. Any unsupported NumPy spelling or +different numerical rule is visible in the matrix and divergence register. + +## 8. Milestone 5 — array semantics and native scheduling + +### 5A. Elementwise traversal + +Define native descriptors for typed buffers, shape, strides, byte order and output +ownership, with overflow-checked extent/offset calculations. Add broadcasting for +scalars, 0-D arrays, singleton dimensions and empty dimensions. Cover C/F layouts, +noncontiguous and negative-stride views, or reject/document unsupported layouts. + +Separate a functional copying adapter from an optimized zero-copy iterator. Report +normalization allocations so layout compatibility does not conceal full-array copies. +Define allowed output-buffer overlap before accepting in-place/aliased execution. + +### 5B. Reductions + +Start with sum/prod/min/max/any/all; assess mean, variance/std, arg reductions and +cumulative operations as subsequent slices, not implicit commitments for 1.0. + +Specify axis normalization, selected-axis combinations, `keepdims`, accumulator +dtype, empty identities/errors, initial values and participating masks. Preserve +the distinction between a logical array reduction and Menudet's explicit block +reduction. Record grouping where it is semantically observable. + +Design native traversal/combination for logical reduction groups independent of +compressed storage chunks. Floating reduction order may differ from NumPy's +platform/layout-dependent algorithm: define accuracy and reproducibility targets +instead of promising universal bitwise equality. Check integer wraparound in both +local accumulation and the combine stage. + +### 5C. Selected shape and indexing operations + +Add the minimum reshape, axis movement and basic slicing needed by high-value +workloads. Distinguish returned values from NumPy view/aliasing guarantees. Defer +general gathers/scatters, advanced indexing and mutable views unless evidence +justifies expanding scope. + +**Acceptance:** C-host examples execute representative broadcast and axis-reduction +expressions without Python, and results retain the declared semantics under different +storage chunking. Native/API ownership, bounds and temporary-buffer behavior are tested. + +## 9. Milestone 6 — graph integration and performance + +Lower semantically eligible safer-LazyExpr graph segments to native execution. +Keep eligibility explicit: recognized syntax alone does not prove matching dtype, +diagnostics, grouping or supported operand capabilities. + +- Introduce an internal/test execution mode that requires native execution for its + supported subset; fail tests on NumExpr calls or Python numerical fallback. +- Establish what remains a Python frontend and demonstrate that exported artifact + execution and native scheduling do not depend on that frontend at deployment. +- Reuse immutable parsed/compiled plans keyed by semantic revision and signatures; + do not cache operand-dependent results across evaluations. +- Fuse compatible arithmetic/function segments while retaining required rounding, + diagnostics and reduction boundaries. Do not use unconstrained fast-math merely + to recover benchmark performance. +- Preserve safe/full deserialization policy, native provenance validation, explicit + table row/partition semantics and unsupported-kernel rejection before writes. +- Make NumExpr optional in packaging only after auditing imports and all intended + construction, metadata, execution and persistence routes in a clean installation. +- Keep ordinary backend fallback distinct from a persisted portable artifact: + portable native execution cannot silently fall back to Python. + +Benchmark native direct execution, integrated graph execution and existing controls. +Use NumPy for numerical references and NumExpr/current Blosc2 for performance +comparisons without assuming equivalent semantics on divergent cases. + +Include tiny/large arrays, float32/64, integers, mixed types, scalar broadcasting, +noncontiguous inputs, partial reads, reductions, persistence and repeated kernels. +Measure compilation, first run, steady state, threading, buffer sizes and peak RSS +separately. Alternate subprocess order and record actual package/native revisions. +Retain isolated baselines from the safer-LazyExpr experiment. + +**Acceptance:** a useful end-to-end subset runs with NumExpr unavailable, backed by +capability tests and measured performance. Agree numerical-workload-specific budgets +after baselining; no arbitrary universal slowdown threshold or unmeasured speedup +claim. Comprehensive allocation bounds remain a separate evidence requirement. + +## 10. Milestone 7 — scope decision, semantic freeze and release + +1. Review every remaining divergence and unverified matrix entry. +2. Choose implement-now, deliberate divergence or unsupported/deferred capability. +3. Freeze type/scalar/operator/function/reduction rules and native diagnostics. +4. Freeze artifact semantic identification and capability negotiation. +5. Verify native interpreter, eligible acceleration, Python integration, persistence, + builds with optional facilities disabled, and supported platform/wheel/WASM jobs. +6. Publish the compatibility matrix, divergences, standalone C example, performance + results and migration notes for development artifacts. +7. Release 1.0 when that declared subset is complete; do not wait indefinitely for + complex numbers, all NumPy APIs or bit-identical host math libraries. + +### Pre-release artifact evolution + +Draft artifacts already exist despite 1.0 being unreleased. Do not reuse an unchanged +semantic identifier for incompatible arithmetic and silently reinterpret them. +Before the first incompatible change, choose a draft revision marker, supported +version transition or explicit rejection policy. Record it in native validation and +Python import tests. A release need not support every historical draft, but must +identify unsupported semantics rather than execute them under different rules. + +**Release acceptance:** all promised capabilities are tested; remaining divergences +are explicit; no required CI failure is hidden by capability skips; examples run +without Python in native hosts; the published claim describes an implemented subset. + +## 11. Divergence register and stopping criteria + +Maintain a single reviewed register with columns: + +| Field | Required content | +| --- | --- | +| ID / operation | Stable identifier, signature and dtype/input category | +| NumPy reference | Pinned version, expected behavior and platform qualifications | +| Current behavior | Actual native result, rejection or missing implementation | +| Category | Value, type, shape, diagnostics, storage, performance or capability | +| Reproducer | Minimal input and conformance case IDs | +| Impact | Relevant workloads and frequency/importance | +| Cost | Implementation, portability, runtime and long-term maintenance cost | +| Decision | Fix for 1.0, deliberate divergence, defer or investigate | +| Evidence | Native/Python revisions, tested platforms and remaining gaps | + +Reassess scope after each milestone. Prefer fixing common arithmetic and promotion +errors over reproducing obscure Python-facing details. Defer behavior that depends +on arbitrary Python objects, unstable platform accidents or disproportionate new +runtime machinery. Document deliberate differences as contracts, not apologetic +footnotes. The register is a release artifact, not a permanently growing hidden todo. + +## 12. Verification and working discipline + +- Native and Python tests must exercise the same declared semantic revision. +- Test actual NumPy/native versions and package paths; CI labels are not evidence. +- Cover Linux, Windows and macOS plus 32-bit WASM behavior. Test NumPy 1.26 host + support separately from the pinned NumPy 2.x semantic reference. +- Run portable interpreter-only builds and eligible JIT/SIMD variants; record + capability skips and pre-execution fallback explicitly. +- Use native sanitizers for arithmetic UB, bounds and lifetime errors where + supported. Stress/sanitizer success is evidence, not a general safety proof. +- Keep ordinary GIL, free-threaded builds and actual no-GIL execution distinct. + Numerical compatibility adds no automatic same-storage mutation guarantee. +- Run Python/build/install commands in the `blosc2` conda environment. Follow each + repository's AGENTS.md and existing C/Cython/Python style and build conventions. +- Add meaningful tests with each behavioral change; run focused checks first and + full native/Python suites at integration checkpoints. Record exact paired SHAs + and local changes included in a result. +- Do not change defaults, add dependencies or publish changes merely because this + plan describes future integration. Those actions follow their normal explicit + project decisions and permissions. + +## 13. First implementation checkpoint + +The first work unit should complete milestone 1 and a small end-to-end slice of 2: + +1. Record both branch starting SHAs and confirm NumPy 2.5.3 as the proposed reference. +2. Inventory existing native type/cast rules and create the initial divergence table. +3. Define the vector schema and add representative cases for integer boundaries, + float32 literals, signed/unsigned promotion, division/remainder and explicit casts. +4. Run them through NumPy generation, native interpreter and Python integration, + preserving current failures as classified evidence rather than changing semantics + and the reference format simultaneously. +5. Select the first milestone-3 vertical slice from measured impact and difficulty; + fixed-width integer arithmetic and scalar promotion are leading candidates. +6. Approve semantic/artifact revision handling before that first incompatible change. + +Thereafter, iterate in small cross-repository slices. Functions, array scheduling +and performance can progress incrementally once their type/diagnostic prerequisites +are stable; there is no need to finish every possible operation in one layer before +demonstrating a useful native workload in the next. diff --git a/plans/menudet-performance-parity.md b/plans/menudet-performance-parity.md new file mode 100644 index 000000000..b621b5dfa --- /dev/null +++ b/plans/menudet-performance-parity.md @@ -0,0 +1,492 @@ +# Menudet/full-DSL performance qualification + +Status: local campaign in progress; optimization changes below are not yet qualified. + +## Reproduction and scope + +The native harness is `../miniexpr/bench/benchmark_profile_parity.c`, driven by +`../miniexpr/bench/profile_parity.py`. The defined matrix has 1,176 recipes, +signatures, distributions and mask variants across Boolean, all standard integer +widths, float32/64, arithmetic, comparisons, logical/bitwise operators, unary math, +casts, mixed types, captures, control flow, reductions, coordinates and libm. +Backends: TCC, Clang, GCC 16 and native interpretation. Sizes: 1K, 64K, 1M, 10M; +interpreter/exception controls are capped at 64K, and large unavailable-JIT pairs +are explicitly reported without timing. Raw output is JSONL with individual +samples, compile/first/warm/allocation timings, JIT availability, semantic +classification, native bridge counts and exact reproduction commands. Generated +C and manifests are retained per job. Normal timings alternate engine order; +first-call timings are diagnostic, always Menudet then legacy. + +Local work directory: +`/private/var/folders/tb/7hwq2y354bb_68xwxjwjwwlr0000gn/T/opencode/`. +The baseline binary is `profile-parity-baseline`; the baseline results are under +`parity-full-baseline/`. The binary contains native revision `00eb5fd` and is not +rebuilt when optimization sources change. No shared editable-install extension +has been overwritten. Python integration checks use the existing isolated +`integer-test-package` via `isolated_menudet.py` and conda environment `blosc2-3.15`. + +## Measurement boundaries + +- The profiles have different numerical contracts; timings are not a universal + equivalence claim. Differences, masks, captures and backend fallback are separate. +- Each worker first verifies up to 1,024 lanes against the Menudet interpreter, + including IEEE flags. Existing native conformance suites remain authoritative. +- Masked work cannot be compared directly to the unmasked legacy API. +- Threshold: ratio >1.25 and absolute difference >5 us; independent reruns must + confirm important gaps before attributing them to code generation. +- One host; no cross-platform performance qualification or hard real-time guarantee. + +## Implemented optimizations (full performance rerun pending) + +- Skip validation scans entirely when no participating mask is supplied. +- Preload input pointers and split generated masked/unmasked entry paths so byte + stores cannot force pointer-table reloads or prevent unmasked vectorization. +- Carry same-width modular integer expression trees as unsigned bits, avoiding + repeated signed-representation materialization. +- Inline strong Boolean bitwise operations and guarded NumPy integer shifts/divmod. +- Avoid math-name registry searches for known interpreter arithmetic nodes. +- Prepared semantic callbacks for min/max, round/sign/square, pi-scaled trig, + logaddexp and exp10; direct fma/ldexp/predicate callbacks. +- Resident partial/stepped NumPy reads evaluate selected safe lane-local recipes + rather than complete original groups; integer comparison outputs can use workers. + +## Validation and current findings + +- Rebuilt native libraries and isolated extension successfully. Build warnings + are existing Accelerate deprecations, generated-C qualifiers/abs and a duplicate + static library; no new warnings in the changed native sources. +- Expanded TCC native parity suite passes, including all integer widths, + boundary/negative/oversized shifts, divmod, bitwise/Boolean and prepared math + values, masks, errors and IEEE status. +- Expanded Clang compact native suite passes. It first caught folded empty + scalar-reduction `0/0` losing invalid status; reduction-result volatile loads + now preserve that status without adding volatile work inside the reduction loop. +- Python resident/decorator integration: 84 passed using conda `blosc2` with + explicitly selected isolated package and rebuilt extension. +- Targeted optimized smoke: 324 result rows, no validation failures; remaining + semantic/unsupported legacy controls stay separate from parity rankings. +- Preliminary 64K-lane math improvements are substantial, but **not final**: + fma about 30–93x, ldexp about 196–199x and sinpi about 35–62x faster than the + frozen baseline on selected TCC/Clang cases. Small wide-type arithmetic timings + also show regressions/noise that require the scheduled large-size rerun; no + blanket performance-parity claim is warranted. + +The serial follow-up coordinator is `finish_parity_campaign.py` in the local work +directory. It waits for the frozen baseline, then runs the full optimized matrix, +native controls, broader Python tests, paired baseline/optimized application +matrix and three-process confirmations. It must finish before final sign-off. + +Final measurements, validation and remaining limitations will replace this status +when the campaign finishes. + +## Arithmetic regression investigation and public evaluate dispatch + +Fresh-process confirmation (`arithmetic-regression.json` in the work directory): +three processes per version/backend/signature, alternating baseline/candidate +order and seven warm samples per process. At 10M lanes the int64 chain is +178.041 -> 17.640 ms with TCC (10.09x); int8 is 130.171 -> 17.554 ms (7.42x). +Clang int8 is 5.411 -> 0.668 ms (8.10x). The apparent 4.4x Clang int64 regression +at 64K does not reproduce: the separate-process residual is 24% at 64K and 5% +at 10M. Removing restrict or the masked function does not consistently fix it. + +To isolate kernels from process/allocation/cache effects, +`check_arithmetic_same_buffers.py` compiles the saved before/after generated C +into separate libraries and alternates 21 calls in one process over exactly the +same inputs and destination. Both aligned and offset views are checked. At 10M: + +| dtype | alignment | before ms | after ms | before/after | +|---|---|---:|---:|---:| +| int64 | base | 2.876 | 2.883 | 0.997x | +| int64 | one-element offset | 2.932 | 2.922 | 1.004x | +| float64 | base | 2.233 | 2.220 | 1.006x | +| float64 | one-element offset | 2.321 | 2.298 | 1.010x | + +64K same-buffer results are within 1%; float64 hot vector-loop instructions are +identical. No reproducible kernel-level regression remains in this diagnostic; +separate-process timings should not be presented as an arithmetic-lowering bug. + +`blosc2.evaluate()` previously excluded math calls and NumPy-input explicit +destinations from automatic native dispatch. Reviewed positional numeric calls +now enter the same native graph/JIT pipeline. Explicit NumPy outputs retain +identity (with a reported copy on the general resident route). New bounded stored +output maps cover integer and mixed NumPy/Blosc2 inputs, including multidimensional +broadcasting, while preserving the existing fast compressed floating prefilter. +Output admission is metadata-only; execution failures are not caught/replayed. +Unsupported cases and backend/accuracy overrides keep existing fallback policy. + +Validation: 291 passed across public evaluate routes, NumPy prefilter/recipe-cache, +native-first maps/sources and resident execution. Numeric division, floor division, +modulo, power and shifts also enter native dispatch with representative API tests. +The new tests explicitly forbid legacy numerical fallback +for the representative 3 input kinds x 3 output kinds x 2 recipe families. + +## Compressed int16 output outlier + +Reproduced `bench/menudet-engines.py --dtype int16 --codec lz4 --clevel 3 +--items 8000000`: Menudet compute took 172.5 ms under cProfile. The general +partition-preserving fallback evaluated the original 8M group once per 1M output +chunk (64M lanes). Eight evaluate_block calls consumed 68 ms, unique/hash 31 ms, +input indexing/decompression 28 ms, plus selection/index construction and copies. +The integer literal excluded the otherwise lane-local recipe from bounded storage +admission, and both Python/Cython prefilter gates only admitted float inputs. + +Reused the resident modular-integer safety proof for storage admission and opened +numeric prefilter metadata gates accordingly. Checked weak subtrees, casts, +reductions, context dependence and unsupported grids retain fallback. Existing +admission for literal-free recipes is preserved. Integer prefilters are now enabled +for eligible compressed Menudet and native-graph output; they are no longer +universally float-only. + +After rebuilding the isolated extension: 512 blocks evaluated once, 16 input chunk +fetches, 750KB worker input scratch. The full benchmark with five warm samples +reported Menudet 2.761 ms (NumPy 6.791, LazyExpr-NumPy 1.531, compressed LazyExpr +6.616, evaluate 1.795 ms; numexpr correctly marked non-parity). An interleaved +same-process control using identical rebuilt kernels and only toggling the old/new +integer dispatch gate measured medians 173.868 -> 4.513 ms (38.52x), five samples +per route after two warmups. These are distinct experiments, not mixed into one +speedup ratio. Profile and comparison scripts/results are in the local work folder +as `profile_int16_stored.*` and `compare_int16_dispatch.*`. + +Tests cover int16 wraparound and uint64 compressed output, requested codec/level, +input chunk fetch counts and rejection of full-group/NumPy staging paths. The +Cython gate change requires rebuilding the extension; shared installed extensions +were not overwritten during this qualification. + +## LazyExpr/evaluate parity for int16 arrays + +Resident profiling reproduced LazyExpr/evaluate ~6.0 ms versus Menudet ~1.5 ms +at 8M lanes, despite all routes already using the same 12-worker resident +scheduler. The graph transports `1` as an immutable weak capture; its narrowed +conversion prevented fusion of the whole modular tree. Generated TCC C retained +three signed representation helper calls per lane instead of one raw-bit store. +Native lowering now absorbs validated, representable immutable integer capture +leaves into the same-width unsigned tree. Checked/computed weak subtrees and +out-of-range capture participation/error behavior are preserved. Cache generation +is bumped. Native tests cover all integer widths, capture bounds, masks and empty +calls, and assert fused source for eligible cases. + +At 100M compressed lanes the graph reader also built/validated 64-bit gather +indices for contiguous input spans. Increasing tile size did not help (37–40 ms +after fusion) and increased scratch. The new automatic large-integer chunk-map +route avoids those indices entirely: isolated single-thread decoders fill reusable +worker scratch; the same artifact writes disjoint NumPy output regions. Scratch +is capped at 32 MiB total, limiting this case to eight workers. Only a metadata- +proven lane-local integer recipe on compatible 1-D layouts is admitted; smaller +arrays, checked expressions and other layouts retain existing routes. All workers +join on failure and no execution is replayed. Decoder floating environments are +isolated and restored even on errors. + +Representative after-run: int16, LZ4 level 3, 12 configured threads, five warm +samples, same benchmark as the user (milliseconds): + +| items | inputs | LazyExpr-NumPy | evaluate | Menudet | +|---|---|---:|---:|---:| +| 100K | NumPy | 0.175 | 0.179 | 0.121 | +| 1M | NumPy | 0.459 | 0.461 | 0.370 | +| 8M | NumPy | 1.853 | 1.928 | 1.681 | +| 100M | NumPy | 18.504 | 18.136 | 18.078 | +| 8M | Blosc2 | 1.340 | 1.697 | 2.827 | +| 100M | Blosc2 | 21.256 | 20.815 | 30.105 | + +For NumPy inputs, all three columns return NumPy. For Blosc2 inputs, Menudet's +benchmark column returns compressed Blosc2 output while the other two return +NumPy, so those columns do not have identical output work. Small resident calls +retain ~50–100 us of graph frontend/admission overhead versus a pre-specialized +Menudet kernel; there is no claim of parity at every size/signature. + +Diagnostics are retained locally as `profile_evaluate_gap.py`, +`probe_compressed_graph_tiles.py` and `probe_direct_chunk_graph.py`. Tests cover +mixed resident/compressed inputs, integer wraparound, explicit output identity, +scratch budget and worker joining on decoder failures. Native/Cython changes +require rebuilding against the local miniexpr checkout. + +Validation for this iteration: 339 Python tests passed (native maps, native-first +selection, evaluate destinations/cache/prefilter, weak captures, storage readers, +resident execution and benchmark correctness); expanded native TCC full and Clang +compact parity suites passed. Lint/format checks passed. Builds retain existing +generated-C qualifier/abs, Cython shared-pointer declaration and duplicate-library +warnings; no new warnings were introduced in the changed native lowering. + +### Wide-integer chunk scratch regression + +The original whole-chunk scratch strategy capped a 100M int64 map with two +1M-item compressed inputs at two workers: 16,000,000 scratch bytes per worker +under the 32 MiB total budget. Profiling reproduced LazyExpr-NumPy 75.75 ms and +evaluate 75.96 ms, with the execution report explicitly showing two threads. + +Scheduling now budgets one physical block per worker first, then selects a +block-aligned sub-chunk batch that fits the unchanged total scratch budget. +For the standard layout this retains 12 workers with 171,875-item batches and +33,000,000 scratch bytes. The decoder accepts bounded aligned offsets/counts; +non-aligned spans reject so the native multi-block destination shortcut cannot +overwrite leading decoded data. Tail batches and integer wraparound are tested. + +After-run (int64, LZ4 level 1, system compiler JIT, five warm samples): + +| items | inputs | LazyExpr-NumPy ms | evaluate ms | Menudet ms | +|---|---|---:|---:|---:| +| 8M | Blosc2 | 4.089 | 4.041 | 3.681 | +| 100M | Blosc2 | 36.264 | 35.128 | 31.154 | + +Menudet returns compressed output in these rows; the other two return NumPy. +The reproduced wide-integer worker-cap regression is removed without raising +scratch memory limits. A companion int16/cc 100M compressed-input run remained +fast (LazyExpr-NumPy 10.285 ms, evaluate 10.136 ms, compressed Menudet 15.496 ms). + +### Compression-driven direct NumPy sink investigation + +An opt-in prototype extends `PortableArtifactHandle.evaluate_prefilter` with +`numpy_out=`. The existing compression workers, input decoders, artifact call, +FP isolation, and error merge are reused. The callback evaluates straight into +the final NumPy slice. Disposable-output callbacks return nonzero to skip the +filter pipeline; C-Blosc2's existing clevel>0 disposable shortcut emits tiny +zero-run placeholder chunks instead of compressing or retaining result bytes. +No C-Blosc2 changes are required. Blosc2 output keeps its original fused +evaluate/filter/compress path. At this initial stage production dispatch was +unchanged; the coarse-worker implementation below supersedes this prototype. + +This removes the old temporary-uncompressed-Blosc2-result/materialization path, +but still uses a small scheduling container and a chunk-sized dummy input +allocation. It is not literally free of all temporary storage. Report fields +identify the destination and placeholder storage size. Integration tests cover +interpreter/JIT execution, reversed binding order, int64 wraparound, output +identity/reuse, canaries around a partial tail, no Blosc2 materialization, no +output zero-fill, and destination validation. + +Correctness-gated `bench/menudet-engines.py` measurements (LZ4 level 1, cc JIT, +12 threads, five warm samples; experimental dispatch installed only by the +local `opencode/bench_numpy_prefilter.py` wrapper): + +| dtype/items | current LazyExpr-NumPy/evaluate ms | prototype LazyExpr-NumPy/evaluate ms | +|---|---:|---:| +| int64 / 8M | 5.039 / 4.807 | 4.032 / 4.084 | +| int64 / 100M | 33.942 / 35.384 | 62.906 / 62.498 | +| int16 / 100M | earlier 10.285 / 10.136 | 19.500 / 19.884 | + +A separate same-input, shuffled-order diagnostic (100M int64 arange, seven +samples, cc JIT) measured direct prefilter fresh output 66.75 ms, reused output +28.19 ms, and the old prefilter/materialization route 112.74 ms. Its current +LazyExpr path measured 48.57 ms; this diagnostic retains more large buffers and +is not interchangeable with the benchmark above. Fresh allocation/first-touch +is a major sensitivity, not yet a proven sole cause. The compression driver +also joins workers once per input chunk, unlike the current coarse partition +of the whole domain; scheduling/locality needs further investigation before +switching dispatch or removing either existing route. + +Validation: 136 tests passed across storage readers, Menudet dispatch, native +graph maps, and LazyExpr output dispatch. Builds/imports used the isolated test +package, not the shared editable extension. + +### Shared prefilter with coarse chunk workers + +The direct NumPy sink now uses the production prefilter callback for eligible +native-first elementwise maps, including mixed NumPy/Blosc2 inputs. NumPy +operands are borrowed directly; compressed operands use the same reusable +decoders and bounded scratch as compressed-output execution. The standalone +integer chunk-map evaluator and its `_portable_chunk_span` binding are removed. +The old temporary-uncompressed-result/materialization branch is also removed. +Persisted, padded-grid, postfiltered, context-dependent, reduction, and other +unsupported cases retain their general bounded-reader/semantic fallbacks. + +For sufficient chunk counts, persistent outer workers own contiguous chunk +ranges and private single-threaded compression contexts. Few large chunks +instead use the same callback with C-Blosc2's internal block workers. A nominal +read-only input buffer is shared across outer workers; the prefilter does not +read it. Each private scheduling container has only one chunk, irrespective of +the source domain. Result chunks are not stored: the driver's tiny disposable +chunks are discarded immediately. Compressed output keeps its original tightly +fused evaluate/filter/compress pipeline and requested output block grid. + +The first coarse-worker attempt serialized at the Python GIL because +`SChunk.update_data` does not release it by default. NumPy scheduling now uses +the existing GIL-releasing `_prefilter_data` adapter. No global GIL-release +setting is changed and no C-Blosc2 modification is needed. All submitted workers +are joined before returning or raising; errors are inspected in range order. + +Tiny source blocks can be grouped into aligned prefilter batches up to 4096 +items, respecting chunk divisibility and the shared application-buffer budget. +The callback validates the original input block headers and decodes each batch +as an aligned span. This avoids a per-physical-block callback/placeholder cost +without duplicating decoding or kernel execution. NumPy output padding is never +written. Compressed-output block sizes and padding behavior remain unchanged. + +Final correctness-gated benchmark (LZ4 level 1, cc JIT, 12 threads, seven warm +samples, fresh output allocation included): + +| items / compressed int64 inputs | LazyExpr-NumPy ms | evaluate ms | compressed Menudet ms | +|---|---:|---:|---:| +| 2M | 1.246 | 1.214 | 1.058 | +| 8M | 3.123 | 3.119 | 3.704 | +| 100M | 23.132 | 23.576 | 31.071 | + +The preceding separate-path 100M baseline was 33.942/35.384 ms for +LazyExpr-NumPy/evaluate. These are separate benchmark invocations, not an +interleaved same-buffer microbenchmark. Reported 100M int64 application-owned +temporary buffers are 11,028,032 bytes: 8,000,000 shared driver bytes, +3,000,000 reusable input bytes, and 28,032 private placeholder-buffer bytes. +This excludes the required 800 MB final output and native context internals; +the application buffers remain within the unchanged 32 MiB cap. Each invocation +fetches 200 input chunks and reuses 24 decoders, with no gather indices, output +copying, or output zero-fill. + +Companion measurements: + +- int16/cc, LZ4 level 1, 100M: 9.912/10.534 ms for LazyExpr-NumPy/evaluate, + versus the prior roughly 10 ms path; no wide-integer improvement is claimed + for this already-fast narrow-integer case. +- float64/cc, LZ4 level 1, 100M: 25.123/23.908 ms. +- int16/TCC, LZ4 level 1, 100M: 20.241/20.405 ms; correctness passed. +- int32/cc, Zstd level 5, 100M: 16.519/16.414 ms. Extending the measured + high-thread crossover to eligible int32/int64 maps also reduces 8M int32 + from 9.016/9.380 to 2.101/2.316 ms; reductions keep their previous floor. +- A probe overriding source blocks to 128 items and chunks to 1,048,576 items + at 8M float64 measured 112.136/112.670 ms before grouping, then + 5.359/5.539 ms after grouping. The retained bounded-reader baseline measured + 45.454/44.446 ms. This is an opt-in layout probe, not the standard benchmark + layout; compressed output intentionally retains its tiny block grid. + +Diagnostics and reproduction drivers are retained under `opencode/`: +`prefilter-coarse-int64-cc.txt`, `prefilter-coarse-int32-zstd-cc.txt`, +`prefilter-coarse-report.txt`, and `bench_prefilter_layout.py`. + +Validation: 840 targeted tests passed across native graph lowering, sources, +stages, math/weak-capture semantics, storage readers, resident execution, +Menudet/public evaluate dispatch, output binding, caching, and benchmarks. +Binding coverage includes mixed source order, NumPy output alias rejection, +tail canaries, tiny chunks, interpreter/JIT operation, failure recovery, and +joining outstanding workers. Ruff lint/format and diff whitespace checks pass. +Builds/imports use the isolated test package; the shared editable installation +has not been overwritten and must be rebuilt before testing this implementation. + +### Resident inputs / uncompressed stored-output allocation profile + +The reproducible 100M int64 NumPy-input to Blosc2-output anomaly (LZ4 level 0 +around 63 ms versus level 1 around 33 ms) was profiled separately. This default +implicit stored-output route still uses `slices_eval` and 50 NumExpr calls; +it does not enter the shared native prefilter. Both levels choose identical +2,000,000-item chunks and 16,000-item blocks. Their output payload/storage sizes +are 800,003,200 bytes at level 0 and 5,673,032 bytes at level 1. + +Shuffled warm timings on the same operands reproduce 62.27 versus 33.56 ms. +The Python profile misleadingly charges the excess to NumExpr `re_evaluate` +(roughly 49 versus 16 ms), while chunk assignment takes roughly 10--14 ms. +Per-phase `getrusage(RUSAGE_SELF).ru_minflt` counters establish the actual +allocation/first-touch sensitivity: + +| control | level 0 warm total | level 1 warm total | level 0 minor faults | +|---|---:|---:|---:| +| fresh output, ordinary NumExpr buffers | 63.5--64.0 ms | 34.3--34.5 ms | about 34,200, in evaluation | +| fresh output, one reused NumExpr buffer | 60.8--61.3 ms | 34.9--35.9 ms | about 33,200, in chunk storage | +| reused Blosc2 destination, original fallback held constant | 31.5--33.1 ms | 33.0--33.5 ms | 0--1 | + +Level 1 incurs fewer than 100 warm faults in these runs. NumExpr result pointers +cycle through 50 distinct buffers per level-0 invocation versus two at level 1; +with explicit scratch reuse both levels use one buffer. Reusing only that +scratch moves the page faults and timing to the storage phase, rather than +eliminating them. Reusing the stored destination recycles already-backed raw +output pages and eliminates the warm allocation penalty. The latter control +explicitly disables native stored-output admission to avoid comparing different +evaluators when an `out=` argument is supplied. + +This is a real fresh-output allocation cost, not slower int64 arithmetic, a +chunk-size change, or a compression-backend regression. Compression keeps this +particular output about 141 times smaller and avoids most of the physical-page +commit/first-touch work and allocator pressure. Once the destination's pages +are reusable, level 0 is slightly faster or comparable, as expected. Merely +reusing a temporary buffer is therefore not a fix. Extending prefilter-driven +stored-output execution to all-resident implicit destinations is a separate +dispatch opportunity; it was not changed during this profiling task. + +Diagnostics under `opencode/`: `profile_numpy_stored_levels.py`, +`profile_numpy_stored_levels.out`, `profile_stored_faults.py`, +`stored-faults-fresh.txt`, `stored-faults-reuse-result.txt`, and +`stored-faults-reuse-output.txt`. Initial qualification checked the complete +result at both levels; phase-counter runs check sampled values without creating +an additional full-size NumPy expected result between timed invocations. + +### Resident-input stored prefilters and allocation-controlled comparisons + +The shared-prefilter work and allocation-profile findings were recorded in +`e168cf93`. The next iteration admits conservative, contiguous, same-domain 1-D +NumPy operands to stored-output prefilter execution. The destination provides +the chunk/block grid; inputs are borrowed directly by the same callback already +used for compressed sources and direct NumPy sinks. This works for implicit +and explicit Blosc2 destinations, preserves storage options, and retains the +existing fallback for unsupported grids, broadcasting, or semantic recipes. +Destination-known scratch admission uses the actual output width rather than +an eight-byte upper bound, so wide logical chunks of int16 output remain bounded +without unnecessarily rejecting this route. No C-Blosc2 change was needed. + +For 100M int64 NumPy inputs, LZ4, cc JIT, and 12 threads, the same benchmark +with fresh stored output now measures: + +| output level | previous chunked NumExpr fallback | resident-input prefilter | +|---|---:|---:| +| 0 | about 62--63 ms | 42.347 ms | +| 1 | about 33--34 ms | 16.290 ms | + +Layouts/storage sizes are unchanged (2M-item chunks, 16K-item blocks; +800,003,200 versus 5,673,032 stored bytes). Execution reports show no input +materialization, decoder contexts, input scratch allocations, or result copy. +Fresh raw output still incurs physical-page costs; the optimization does not +pretend to eliminate allocation of its required 800 MB destination. An int16/cc +LZ4-level-1 companion run measured resident-input compressed LazyExpr output +6.211 ms at 100M, with numerical qualification passing; compressed-input +LazyExpr-NumPy/evaluate remained 9.834/9.678 ms. + +The NumExpr allocation hypothesis is also confirmed directly. An independent +same-input, shuffled eleven-sample comparison with one shared, warmed NumPy +destination produced these medians (100M int64, cc JIT, 12 threads): + +| engine / allocation policy | ms | minor page faults | +|---|---:|---:| +| NumExpr / fresh | 40.675 | 48,829 | +| NumExpr / reused `out=` | 13.649 | 0 | +| evaluate / fresh | 15.737 | 48,829 | +| evaluate / reused `out=` | 11.458 | 2 | + +Before this iteration `evaluate(out=...)` still allocated a full resident result +and copied it into the requested output: 43.656 ms and 48,829 faults in the +initial control. The existing resident worker path now accepts the final output +buffer directly, validates shape/dtype/layout and overlap, and retains its +join-before-error behavior. No parallel resident result copy/allocation is +needed for this control. General nonparallel/unsupported fallbacks are unchanged. +Fresh NumExpr and evaluate have similar fault counts but very different +aggregate kernel CPU times (about 356 versus 93 ms across all threads in the +follow-up run), so counts alone do not characterize first-touch cost. This does +not establish the precise kernel locking/scheduling mechanism behind that +difference. With page faults removed, NumExpr throughput is competitive rather +than the approximately 2.6x gap suggested by fresh-output wall time. + +`bench/menudet-engines.py --allocation-control` now appends a correctness-gated +fresh/reused NumPy-output comparison for NumExpr and evaluate on resident inputs. +It shares one prepopulated output buffer between the sequential reused cases, +does not time operand decompression, and leaves the original table's fresh-output +policy unchanged. Reductions and compressed-only rows reject this option rather +than silently changing their measurement contract. Example: + +```sh +python bench/menudet-engines.py --dtype int64 --codec lz4 --clevel 1 --jit cc \ + --items 100000000 --operands numpy --allocation-control +``` + +The corresponding five-sample CLI control measured NumExpr fresh/reused +41.576/13.606 ms and evaluate fresh/reused 16.485/11.313 ms. Diagnostic scripts +and outputs remain under `opencode/`: `compare_resident_allocation.py`, +`resident-allocation-comparison.txt`, `resident-allocation-direct-output.txt`, +and `profile_resident_prefilter_levels.out`. + +Validation covers resident stored-output defaults/explicit destinations, partial +tail padding, file metadata, parameter immutability, input rebinding, no fallback +after execution failure, and explicit resident NumPy output without a full-size +temporary or copy. The previous native-first failure test now targets NumPy +output so it continues testing that execution layer rather than the newly +admitted stored prefilter. The focused integration suite passes 849 tests; +additional expression graph, lifetime, ingestion, and resident suites pass 543. +Lint/format and diff whitespace checks pass. + +The user reconfigured `build-portable-python` for Python 3.15 while recompiling. +This iteration leaves that configuration and the shared editable install alone. +Its conda-blosc2 build is isolated at `opencode/build-resident-prefilter`, reuses +the same local miniexpr source override, and loads refreshed extensions only in +the isolated test package. Rebuild the editable extension before user-side runs. diff --git a/plans/miniexpr-implementation-results.md b/plans/miniexpr-implementation-results.md new file mode 100644 index 000000000..b5152b096 --- /dev/null +++ b/plans/miniexpr-implementation-results.md @@ -0,0 +1,166 @@ +# Native execution and NumExpr-removal evaluation + +Latest follow-up: [no-jit-and-small-math.md](no-jit-and-small-math.md) substantially +reduces the interpreter-only gap and improves small transcendental scheduling. +The original no-JIT timings and release tradeoffs below are historical snapshots. + +Follow-up contiguous-kernel JIT lowering and its measurements are tracked in +[contiguous-jit-lowering.md](contiguous-jit-lowering.md). That pass removes more +per-operation interpreter callbacks and the chunk path's forced no-JIT policy; +it does not eliminate the explicit no-JIT interpreter gap documented here. + +Implementation branches: `improved-miniexpr` in Python-Blosc2 and miniexpr. + +Implementation boundaries: Python-Blosc2 `69930b98` (native integration), +`b64cff00` (runtime removal) and `06863bfa` (memoryview owners); native miniexpr +head `92caba958102f1ae182a6a344cee6227e8c4175e`. Python's build pin and paired +qualification pin both identify that native head. These are local commits. + +## Delivered + +- Versioned native output descriptors, negative strides, bounds/alignment and + conservative self-overlap validation; old contiguous APIs remain compatible. +- Bounded output scatter for maps and addressed stores for serial reductions, + including graph sources, conversions and staged final destinations. +- Native map-partition safety, synchronous host executors, task preflight/joins, + deterministic failure selection and aggregate iterator-workspace budgets. +- Destination-friendly traversal/partition axes for certified resident maps. +- Native identity copies without arithmetic-kernel interpretation or compilation. +- Python binding of actual allocation bounds, direct strided outputs and native + graph scheduling through a host executor. Fused compression remains intact. +- No NumExpr runtime import/calls/dependency/thread initialization. NumPy handles + unsupported functionality. `prepare_evaluate`/`re_evaluate` remain available. + +## Local performance + +M4 Pro, eight workers, 8M float64 elements, explicit shared warmed NumPy output, +seven timed samples after warmup, randomized engine order. Public API overhead is +included; preparation/compilation warmup and fresh-result allocation are excluded. +NumExpr is an external comparison package, not a Blosc2 backend. + +| Recipe | NumExpr ms | Native JIT ms | Native interpreter-only ms | +| --- | ---: | ---: | ---: | +| Linear | 1.177 | 1.196 | 79.264 | +| Polynomial | 1.561 | 1.139 | 96.385 | +| Division | 1.121 | 1.164 | 50.947 | +| Power | 4.876 | 5.034 | 29.366 | +| Square-root norm | 1.490 | 1.072 | 127.497 | +| Sine + cosine | 3.827 | 4.213 | 138.661 | +| log1p + expm1 | 4.694 | 4.507 | 151.463 | +| Hypot | 1.296 | 1.366 | 89.771 | +| Fmod | 3.494 | 3.691 | 124.768 | +| Rounding | 2.209 | 1.555 | 200.759 | +| Predicate | 1.482 | 1.060 | 62.576 | +| Selection | 1.375 | 1.175 | 70.955 | +| Copy | 0.803 | 0.729 | 0.697 | +| Sum of products | 6.764 | 1.312 | 30.634 | + +JIT and interpreter measurements are separate runs, not paired cross-backend +samples. Their NumExpr controls were similar but not identical. Copy uses a +native memory-copy shortcut, not the interpreter or JIT arithmetic kernel. +Automatic parallel sum policy still uses the existing Python host adapter. + +At 100M float64 elements, interpreter-only configuration copied into a reused +destination in **7.021 ms**, versus NumExpr **10.159 ms** (15 samples). This is +genuine JIT-disabled native execution, unlike the earlier NumExpr fallback run. + +Complex construction is an explicit NumPy fallback: a separate 8M-element run +measured **4.696 ms** versus NumExpr **1.466 ms**. It fills the real and imaginary +destination components directly, avoiding a full complex result followed by a +copy, but remains slower and is not native complex support. + +An initial native scheduling experiment retained 1K-element tiles and regressed +large JIT maps to roughly 2.6–3.0 ms. Native automatic executor tiling (up to 64K +elements within workspace limits) restored the competitive JIT results above. + +### Integer math and memory layouts + +The native proof was subsequently extended to safe real-math promotion of integral +arrays (without admitting checked integer division, casts or powers). At 8M +int64 elements with JIT/eight workers, formerly serial cases became competitive: + +| Integer-input recipe | NumExpr ms | Native JIT ms | +| --- | ---: | ---: | +| Division | 1.294 | 1.138 | +| Square-root norm | 1.786 | 1.085 | +| Sine + cosine | 5.478 | 4.799 | +| log1p + expm1 | 5.109 | 4.454 | +| Hypot | 1.801 | 1.385 | +| Fmod | 2.937 | 2.293 | +| Selection | 1.569 | 1.280 | + +For matching F-order inputs/output of shape `(2000, 4000)`, float64 JIT timings +were linear **1.193 ms**, polynomial **1.157 ms**, norm **1.069 ms**, copy +**0.716 ms**, versus NumExpr **1.168/1.560/1.482/0.806 ms** respectively. +Conflicting C-input/F-output layouts remain a performance gap: polynomial/norm +were about **15 ms** versus NumExpr **8.0/7.2 ms**, and copy **7.2 ms** versus +**2.4 ms**. These need blocked gather/scatter/cache/TLB optimization, not another +Python execution path. + +### Reproduction commands + +Use the `blosc2` conda environment with extensions built from these branches: + +```sh +conda run -n blosc2 python bench/evaluate-numpy-parity.py --items 8000000 --backend jit --threads 8 --samples 7 --json jit.json +conda run -n blosc2 python bench/evaluate-numpy-parity.py --items 8000000 --backend interpreter --threads 8 --samples 7 --json interpreter.json +conda run -n blosc2 python bench/evaluate-numpy-parity.py --items 100000000 --cases copy --backend interpreter --threads 8 --samples 15 +conda run -n blosc2 python bench/evaluate-numpy-parity.py --shape 2000 4000 --input-order F --order F --backend jit --threads 8 +``` + +The script verifies JIT availability/request and numerical/output qualification. +Non-equivalent or unsupported reference cases remain `N/A`. Compare both fresh +and reused allocations separately when extending these measurements. + +## Qualification and interpretation + +Native validation includes standalone release tests, ASan/UBSan graph/array +tests, and actual Emscripten/Node wasm32 graph/array tests. Python validation +includes descriptor bindings, real host-worker execution, join-on-submission +failure, ordinary expression regressions and NumExpr import-blocking processes. +Final counts/build outcomes are recorded below. + +Confirmed qualification so far: + +- Standalone native release suite: **354 passed**. +- Native graph/array tests: **11 passed** under ASan/UBSan and **11 passed** + under actual Emscripten/Node wasm32 (repeated after the integer-policy update). +- Independently built/extracted wheel with NumExpr imports blocked: **11,721 + passed** in the earlier run. The final wheel rerun passed **11,726 tests**, + with 136 skipped and 12,907 deselected, including the configured doctests and + the compatibility-hint/native-policy changes. +- A dependency-only search path excluding both the NumExpr module and its + distribution metadata passed **176 targeted tests** (24 external-reference + cases skipped). No import blocker was necessary in that genuinely absent + dependency configuration. +- A final memoryview-owner fix was checked with **182 targeted tests** and the + genuinely absent dependency configuration above; it snapshots disjoint views + sharing a buffer owner when native allocation-level alias rules require it. +- Wheel metadata contains no `Requires-Dist: numexpr`; shared editable extensions + and the user's Python 3.15 build directory were not overwritten. + +Earlier qualification harness issues were fixed without changing product behavior: +the isolated runner needed a multiprocessing main guard, and doctests needed a +clean working directory to avoid existing fixed-name user data files. No user +data file was removed to make the doctests pass. + +Builds used the local native source override +`-Ccmake.define.FETCHCONTENT_SOURCE_DIR_MINIEXPR=/absolute/path/to/miniexpr`. +Native commits are local to the development branch until published; the aligned +Python/native pin is not a claim of remote CI qualification or fetch availability. + +The main unresolved issue is **no-JIT arithmetic throughput**, not correctness or +availability of a native interpreter. Its scalar recursive evaluator is visible +in `src/dsl_portable_expr.c`; optimization should be driven by profiles and native +numerical qualification rather than replacing checked semantics with unchecked +vector loops. A vector/bytecode interpreter is a likely follow-up, not implemented +or claimed here. + +Other remaining architecture work: concurrent reader capabilities, a public +C-Blosc2 executor adapter, migration of existing automatic parallel-reduction +policy/non-graph portable-DSL proofs, and fuller mixed-layout optimization. +Windows/runtime CI and remote qualification evidence remain separate checks. + +**Decision:** the runtime dependency can be removed functionally, and native JIT +maps/copies remain competitive. Shipping the removal for JIT-unavailable users +requires an explicit decision about the substantial interpreter regression. diff --git a/plans/no-jit-and-small-math.md b/plans/no-jit-and-small-math.md new file mode 100644 index 000000000..349e14b40 --- /dev/null +++ b/plans/no-jit-and-small-math.md @@ -0,0 +1,139 @@ +# No-JIT arithmetic and small transcendental workloads + +Native revision: `27cddcda43a33390542fdf7ca74aacd191c26b22`. Both Python build +and paired-qualification pins identify this local native commit. Local builds +use the source override; this is not a claim of remote fetch/CI availability. + +## Delivered + +- A bounded straight-line **vector interpreter**, not runtime code generation. + Eligible float32/float64 arithmetic, strong same-width modular integer + arithmetic, total numerical conversions and qualified unary math use static C + primitives instead of recursively evaluating every tree node for every lane. +- Each intermediate retains its dtype/rounding. No fast-math, FMA contraction, + reordered reductions or unchecked float-to-integer casts were introduced. +- Private workspace is bounded by 64 slots × 256 doubles = **128 KiB per active + invocation**, plus existing iterator/DSL state. This is not full-result staging + and is additional to the executor's iterator-scratch budget. +- Partial masks, checked operations, potentially uninitialized locals, excessive + plan size/depth and unsafe aliases decline before execution. Exact same-lane + in-place buffers are supported; other overlaps retain scalar traversal. +- Native scheduling distinguishes costly math from bandwidth-oriented maps: + automatic thresholds are 16K versus 128K elements, with at most four tasks for + small math jobs. Explicit host thresholds still override that policy. +- Eligible serial executor fallbacks use bounded automatic tiles rather than + repeatedly invoking a 1K-element kernel. Python's synchronous caller also runs + one task, saving a pool submission; joining futures directly avoids `wait()`'s + extra notification registration. An invocation gate prevents late jobs from + using freed native pointers even if `submit()` enqueues work and then raises. + Join state is allocated before submission. Failure/interruption paths join + every already-entered native call before invocation state is freed. + +The mechanisms live primarily in miniexpr (`dsl_portable_expr.c`, the new +`dsl_portable_batch.c/.h`, and `dsl_graph.c`). Python only adapts the host executor. +NumExpr remains an optional external benchmark reference, never a runtime backend. + +## Measured improvements + +M4 Pro, eight configured workers, contiguous float64 resident inputs and a shared +warmed NumPy destination. Public API overhead is included. Compilation and fresh +result allocation are excluded. Before measurements use the previous independent +wheel; after measurements use isolated rebuilt extensions. These are separate +runs, with shuffled engine order within each run, not interleaved old/new builds. + +### Genuine no-JIT execution: 8M elements + +Both `ME_DSL_JIT=0` and Python's no-JIT policy are selected. The native probe +reports `has_jit=False`; no compiler is invoked by the vector interpreter. +Fifteen samples after five warmups: + +| Recipe | Before ms | After ms | Speedup | NumExpr ms (after-run control) | +| --- | ---: | ---: | ---: | ---: | +| Linear | 74.807 | 4.351 | 17.2× | 1.206 | +| Polynomial | 95.120 | 3.601 | 26.4× | 1.568 | +| Division | 49.373 | 4.000 | 12.3× | 1.107 | +| Square-root norm | 123.236 | 4.233 | 29.1× | 1.519 | +| Sine + cosine | 140.120 | 6.440 | 21.8× | 3.849 | +| log1p + expm1 | 153.143 | 7.577 | 20.2× | 4.683 | + +No-JIT integer-input arithmetic also improves. At 8M int64 elements, seven +samples after three warmups: linear **83.478 → 3.438 ms**, polynomial +**133.319 → 4.016 ms**, true division **65.987 → 3.976 ms**, norm +**153.985 → 4.790 ms**. Intentional dtype differences remain excluded from parity. + +### Small JIT workloads: 100K elements + +System-CC JIT, 31 samples after ten warmups: + +| Recipe | Before ms | After ms | Speedup | NumExpr ms (after-run control) | +| --- | ---: | ---: | ---: | ---: | +| Sine + cosine | 0.437 | 0.219 | 2.0× | 0.125 | +| log1p + expm1 | 0.535 | 0.254 | 2.1× | 0.134 | +| Fmod | 0.394 | 0.238 | 1.7× | 0.138 | +| Hypot | 0.209 | 0.192 | 1.1× | 0.115 | +| Square-root norm | 0.180 | 0.184 | 1.0× | 0.116 | +| Linear | 0.125 | 0.114 | 1.1× | 0.110 | + +Cheap maps do not gain parallelism just because the math threshold changed. +Large JIT maps retain the existing compiled route; the vector interpreter is not +silently substituted for it. + +### What did not work + +An initial vector path declined the interpreter's non-null all-ones masks and +therefore did not execute on ordinary graphs; explicit batch-admission counters +in the native tests now guard this. Typed bit fills and uniform conversions were +important to avoid replacing tree dispatch with per-lane conversion dispatch. +A larger 1024-lane private vector experiment regressed the sampled large maps; +the implementation retains 256-lane vectors and the 128 KiB bound. + +## Qualification + +Native tests compare vectors against one-lane scalar execution, not against the +same optimized path: float32/float64 values and FP status, signed zeros, signaling +and quiet NaNs, infinities, subnormals, overflow/underflow, all integer widths, +rounding-sensitive casts, full/partial masks and odd tile tails. Private counters +verify admission and conservative declines. Additional tests cover shifted and +exact aliases, initialized-local failures, and checked-cast prefix/error behavior. +Python tests exercise real small-math tasks, caller participation, output identity +and complete joining after submission failures or interrupted waits, including +late jobs whose `submit()` call raised after enqueueing them. + +Qualification: **11,677 Python tests**, **354 native release tests**, +**12 ASan/UBSan tests**, and **12 actual wasm32 tests** passed. The native counts +include the scalar-versus-vector parity and fallback tests. The real TCC parity +matrix passed too. The independently built wheel passed **168 targeted tests** +with both NumExpr's module and distribution metadata absent (24 external-reference +cases skipped), plus **120 doctests** (two skipped) in a fresh working directory. +Wheel metadata has no NumExpr runtime dependency. Shared editable extensions and +the user's separate Python 3.15 build were not overwritten. +The wheel also executed float32/float64/int64/uint64 arithmetic with JIT disabled, +NumExpr absent and `CC` pointing to a nonexistent compiler, reporting zero JIT +stages and exact expected results. + +Native release builds introduce no compiler warnings. The Cython rebuild still +emits warnings in unchanged +declarations/constness/`abs` code and the existing duplicate-library link setup; +these are not new warnings from the batch primitives. + +## Remaining performance gap + +This is **not universal NumExpr parity**. The six covered no-JIT float64 recipes +above are now about **1.6–3.7×** slower, rather than tens of times slower; small transcendental +JIT maps remain roughly **2×** slower. Remaining costs include intermediate-tile +traffic, instruction/operation dispatch, scalar libm callbacks, and host launch/API +overhead. Unsupported masked/checked recipes, binary math and predicate/select +operations outside the initial subset still use the scalar interpreter. +Actual Windows runtime qualification remains separate from local macOS/wasm32. + +## Reproduce + +Use conda environment `blosc2` with extensions from the matching native checkout: + +```sh +conda run -n blosc2 python bench/evaluate-numpy-parity.py --items 100000 8000000 --backend interpreter --cases linear polynomial division sqrt trig log-exp --samples 15 --warmups 5 +conda run -n blosc2 python bench/evaluate-numpy-parity.py --items 100000 --backend jit --cases linear sqrt trig log-exp hypot fmod --samples 31 --warmups 10 +``` + +The benchmark verifies dtype, values, output identity and JIT availability before +timing; unsupported or non-equivalent reference signatures remain `N/A`. diff --git a/plans/portable-DSL-1.0-implemenation.md b/plans/portable-DSL-1.0-implemenation.md new file mode 100644 index 000000000..a01531f31 --- /dev/null +++ b/plans/portable-DSL-1.0-implemenation.md @@ -0,0 +1,503 @@ +# Portable DSL 1.0 implementation plan + +Date: 2026-10-07. Status: implementation plan; all three detail decisions +below are confirmed by the user. Feature scope and earlier semantic decisions are +approved in `portable-DSL-1.0-scope-inventory.md`. This file intentionally uses +the requested filename. + +## Objective and shortest implementation path + +Deliver a public, versioned kernel contract executable from C and Python, with +portable-only new kernel persistence. Build correctness in the native +**interpreter first**. Reuse existing parsing, expression evaluation, strings, +ND support and artifact loading; do not implement a second language engine. + +Initially route every 1.0 kernel through the interpreter. Subsequently enable +only existing JIT paths whose semantics are demonstrated compatible. Missing +JIT support, including checked arithmetic, masked reductions or strings, is +never a reason to delay interpreter delivery or weaken the contract. + +Draft portable 1.0 is the sole public portable format and the authoring/validation +default. The unreleased 0.1 profile is retired, with explicit unsupported-version +rejection rather than migration or reinterpretation. Ordinary full-DSL +execution keeps its existing semantics. Miniexpr owns normative semantics, +validation and conformance; Python-Blosc2 owns normalization and host integration. + +## 0. Confirmed behavioral choices + +The user approved Q1–Q3 below. Their recommended rules are now implementation +requirements; the explanations preserve the rationale for these choices. + +### Q1. Complete the numeric type policy + +Recommend Boolean, signed/unsigned 8/16/32/64-bit integers, and float32/float64. +No float16, complex, object, datetime or structured arithmetic in 1.0. + +Proposed promotion rules: + +- Same typed operands retain their type; Boolean arithmetic uses int64 numeric + zero/one, with `/` producing float64. Boolean logical operations remain Boolean. +- Same-signedness integers widen to the wider operand. Mixed signed/unsigned + integers use the smallest signed type covering both complete operand ranges. + Reject an implicit combination for which no such type exists, notably + int64/uint64; explicit float conversion remains possible with documented loss. +- float32 with float32 stays float32; float64 dominates. Integer/float mixtures + use float32 for integers of at most 16 bits and float64 otherwise. Conversion + to float64 may round 64-bit integers; document this rather than claiming exactness. +- Weak source literals adopt an accompanying typed operand when within range. + Decimal floating literals round once to the selected IEEE type using nearest, + ties-to-even; do not require exact binary representability of `0.1`. + An out-of-range contextual literal is rejected, requiring an explicit cast or + typed constant. Literal-only integers default to int64 and floats to float64. +- Typed captured constants are strong operands, not weak literals. `int()` yields + int64, `float()` yields float64, and `bool()` yields Boolean. Explicit typed + casts, if admitted in the builtin matrix, have precisely named destination types. +- Arithmetic promotion does not define comparisons by accident: compare mixed + signed/unsigned integers exactly without lossy float intermediates. Reject any + unsupported mixed comparison explicitly in the initial matrix. + +Why approval matters: uint64 is useful, but there is no exact fixed-width signed +common type with int64. This policy chooses a diagnostic rather than implicit +float64 rounding for their arithmetic. Narrow integer arithmetic can overflow +before final widening, consistently with operand-driven computation. + +### Q2. Represent block-scalar outputs in the lazy host + +Recommend explicit result cardinality in the artifact: `elementwise` or +`block_scalar`. A standalone C block evaluation returns one value for the latter. +In Python lazy execution, expose one value per logical evaluation block, on the +block-grid shape, with row-major block ordering. Do not broadcast an actual +block-scalar return back to every element implicitly. + +A scalar reduction used inside an elementwise calculation broadcasts to its +participating lanes; that does not itself make the kernel block-scalar. +Reject paths with inconsistent return cardinality. A block-scalar partial read +indexes output blocks; an elementwise partial read evaluates original input +groups before selecting lanes. Empty input arrays have no scheduled blocks; +an explicitly evaluated empty standalone block still obeys reduction identities. + +Why approval matters: today's artifact API assumes `nitems` output values. +Silently keeping that allocation model would confuse scalar reductions with +elementwise results and obscure what a saved array's shape means. + +### Q3. Reuse the existing legacy opt-in + +Recommend user-supplied `deserialize="full"` as the legacy-kernel opt-in, rather +than adding another public switch. Normal/default safe opens must not reconstruct +legacy Python kernels. Propagate the effective policy through nested operands; +internal calls that hard-code `full` must not grant permission on the user's +behalf. If existing API defaults cannot distinguish explicit permission from an +implicit default, adjust the boundary/policy propagation before admitting legacy +execution. Portable artifacts need native validation, not Python reconstruction. + +No migration tool, automatic conversion, or legacy-save fallback is planned. +Manual adaptation guidelines are the only conversion assistance. + +## 1. Establish a small normative contract and baseline + +Files: `../miniexpr/doc/dsl-spec/1.0.md`, `artifact-1.0.md`, a machine-readable +feature/type/function matrix, and `../miniexpr/tests/portable-dsl/` fixtures. + +1. Retire unreleased 0.1 validation/loading and obsolete freeze documents. Retarget + useful encoding/numeric/masking/validation fixtures to draft 1.0, updating + independent references for operand typing and checked arithmetic. +2. Inventory actual builtin registrations and interpreter implementations once. + Classify each operation as included, existing full-DSL only, or excluded; + include arity, type combinations, result type, errors and accuracy policy. + Avoid another unbounded backend audit. Review omissions of useful existing + operations before freezing the matrix. +3. Cover arithmetic, comparisons, bitwise operations, shifts, casts, `where`, + control flow, supported math, fixed-width string operations, ND symbols and + the existing numeric/Boolean reduction families. Do not assume scalar and + reducing forms of similarly named functions share semantics. +4. Spell out floor division/remainder signs, integer power and shift overflow, + signed-zero behavior, NaNs, infinities, local type joins, short-circuiting and + evaluation order. Recommend typed locals with a statically determined join + type and rejection when no supported join exists; no dynamic dtype changes. +5. Specify loop caps and missing-return errors. Resource caps are host policy; + an error must not become a partial successful result. Preserve existing + configured caps rather than inventing a new execution sandbox. +6. Use semantic capability IDs for ND context, fixed strings and block reductions. + A declared capability is a requirement, not permission to skip validation. + +Exit: a finite matrix and example fixtures cover every admitted operation; +no undefined implementation behavior is advertised as portable semantics. + +## 2. Introduce versioned semantic compilation and conservative dispatch + +Primary files: native `dsl_portable.c`, `dsl_compile.c`, +`dsl_compile_internal.h`, `dsl_compile_support.c`, `dsl_artifact.c`. + +1. Thread a portable semantic profile through compilation and compiled program + metadata. Keep it out of process-global mutable switches. +2. Validate normalized source, resolved call targets, compiled node types, + effects, return cardinality and inferred capability requirements. Use both + source and typed-tree gates. +3. Reject callbacks, complex values, `print`, fast/contract FP, dynamic widths, + arbitrary memory access and unsupported reduction placements. A reduction + condition inside a loop is not a reduction assignment in the loop body. +4. Initially mark every 1.0 program interpreter-only. Optional JIT requests fall + back before compilation/execution of an incompatible backend. Explicit + required-JIT requests fail clearly when no certified path exists. +5. Preserve source locations through compilation and expose stable unsupported, + binding, format and evaluation error categories. + +Exit: 1.0 kernels cannot accidentally execute +under full-DSL output-context typing or an uncertified JIT. + +## 3. Implement checked operand-typed numeric interpretation + +Primary files: `dsl_compile.c`, `dsl_eval.c` and the shared native expression +typing/evaluation helpers they call. Locate shared helpers before changing them; +make changes profile-aware where ordinary DSL semantics differ. + +1. Infer every expression's computation dtype independently of declared output. + Preserve weak-literal metadata until contextual typing is complete. Insert + explicit typed conversion nodes rather than relying on output buffers. +2. Implement the approved promotion table and casts. Round float32 intermediates + at operation boundaries; prohibit implicit contraction/reassociation in the + strict profile. Test that changing output dtype does not change intermediates. +3. Implement checked integer add/subtract/multiply/negation, division/remainder, + shifts, powers and all narrowing/conversion paths actually admitted by the + matrix. Check before performing a C operation that could overflow or be UB. + Do not rely on signed overflow, invalid shifts or out-of-range C casts. +4. Check float-to-integer limits without rounded-boundary errors, including + int64/uint64 extrema. Fractional values truncate toward zero before range + acceptance is decided. Cover exact large integers without double round trips. +5. Apply numeric-zero/one Boolean arithmetic consistently to intermediates, + explicit casts and final output. Preserve fractional division before truth. +6. Propagate failures from nested expressions and final conversions. Only active + lanes execute checked operations. Short-circuit branches and `where` must not + report failures from unselected lanes; implement masked operand evaluation + rather than evaluating invalid discarded branches eagerly. +7. Document floating math domains and per-function tolerances. Use a bounded + cross-platform accuracy contract informed by existing libm implementations; + do not make bitwise transcendental equality a release requirement. +8. Keep workspace and error state per evaluation. On failure, native output is + unspecified and must not be consumed; Python raises rather than caching or + returning that block as a successful result. + +Exit: exact integer/error cases, Boolean fractions, float32 rounding, mixed +types and inactive invalid branches pass interpreter conformance on native and +WASM targets. Additional JIT arithmetic work is unnecessary for this milestone. + +## 4. Make masking and limited block reductions explicit + +Primary files: `dsl_eval.c`, `dsl_eval_internal.h`, `dsl_compile.c`, +`miniexpr_eval_reduce.c`, and ND evaluation adapters. + +1. Represent valid lanes and currently participating lanes explicitly. Track + branch, loop, break, continue and return masks; nested conditions reduce over + the mask participating at that program point. Continue excludes the rest of + that iteration but does not permanently remove a lane from the next one. +2. Top-level reductions see valid block elements; nested supported conditions see + active valid elements. Never include padded lanes or stale local storage. +3. Retain the restriction on reduction-valued assignments/returns in control-flow + bodies. Admit top-level reductions and supported conditions, including nested + `if all(...)` in Mandelbrot. Validate placements structurally, not by a string + search or a blanket ban on nonzero nesting depth. +4. Accumulate in logical C-order within a block; skip inactive lanes without + changing the order of remaining lanes. Disable parallel/tree reduction and + fast reduction shortcuts for this profile unless they give the required order. +5. Recommended operation details for the normative matrix: widen signed/Boolean + sum/prod to int64 and unsigned to uint64; keep floating sum/prod input dtype; + integer mean uses float64; floating mean uses its floating input dtype. + Checked integer accumulation applies at every step. Mean uses the specified + ordered sum followed by division by the participating count. +6. Use approved empty identities for any/all/sum; recommend prod(empty)=1 and + mean(empty)=NaN. Empty min/max errors. Recommend NaN propagation for numeric + reductions, deterministic signed-zero ties for min/max, and NaN-as-true for + truth reductions, consistently with Boolean conversion. Record these rules + explicitly and compare against existing behavior before implementation. +7. Distinguish reduced scalars from per-lane values in compiled metadata and + allocation. Broadcast scalar operands only onto participating lanes. + +Exit: Mandelbrot interpreter results survive changes in partition when its +early-exit optimization is semantically neutral; a deliberately block-dependent +example changes exactly as specified. Include partial masks, edge padding, +empty groups, continue/break/return, ordered cancellation and overflow cases. + +## 5. Extend native artifacts for context, widths and cardinality + +Primary files: `dsl_artifact.c`, `miniexpr_artifact.h`, `dsl_portable.c`. + +1. Keep standalone UTF-8 JSON, explicit schema/language versions, strict semantic + requirements, named signatures, exact typed constants and optional bindings. + Extend integer encodings for the admitted widths; retain decimal integer + strings, IEEE floating hex and Boolean values. +2. Add string descriptors with code-unit kind and fixed width. Recommend canonical + hex bytes for bytes constants and fixed-endian 32-bit code-unit hex for Unicode + constants, preserving values without assuming all slots are valid UTF-8 text. + Native buffers use host representation; adapters perform endian conversion. +3. Add result cardinality and queries for itemsize/output capacity. Introduce an + extended evaluation descriptor/API rather than silently changing the old + `me_artifact_eval()` ABI, whose output currently has `nitems` elements. +4. The extended call supplies logical shape, block origin/extent, valid-lane + description and explicit output capacity. Define `_flat_idx` in the logical + domain, `_i` as coordinates in that domain and `_n` as logical sizes. + Broadcasting inputs does not change the output coordinate domain. +5. Validate required context, dimensions, products, byte capacities, integer + conversions, ownership and overlap before evaluating. No array-sized constant + replication; no mutable context retained on a shared handle. +6. Distinguish zero-element elementwise calls from explicitly empty block-scalar + reduction calls; the latter must execute empty-group semantics. +7. Validate inferred capabilities against artifact declarations. Unknown versions + or unavailable capabilities fail explicitly, without Python reconstruction. + +Exit: a standalone C runner loads each capability fixture and evaluates supplied +buffers/context using only native code; incorrect descriptors fail deterministically. + +## 6. Admit existing fixed-width strings and logical ND kernels + +Native files: existing string implementation, `miniexpr_eval_dsl_nd.c`, +`miniexpr_eval_nd.c`, plus compile/validation and artifact descriptors above. + +1. Reuse native string operations and width inference. Specify first-NUL behavior, + full-width unterminated slots, no Unicode/bytes mixing, bytes comparison rules, + Unicode code-unit order, case-expansion truncation and static width bounds. +2. Pin the Unicode mapping/whitespace data semantics used by admitted operations; + avoid locale-dependent behavior. Separate arbitrary byte constants from the + current restriction on non-ASCII source literals used against bytes operands. +3. Check branch/local width joins and allocate the inferred return width, not a + NumPy approximation. Reject unbounded results before execution. Keep strings + interpreter-only; a host may pack fixed-width output into varlen storage. +4. Define sliced/view authoring domains explicitly: a newly constructed kernel + over a view has its declared logical domain; reading a slice of an existing + saved kernel retains that kernel's original coordinates and reduction groups. +5. Exercise zero-input constructors using ND context, sliced domains, broadcasting + and padded edge blocks. Pass context through native evaluation, not synthetic + Python callbacks or hidden global arrays. + +Exit: representative existing string/ND kernels export and execute identically +in C and Python, including widths and coordinates, with no JIT dependency. + +## 7. Python bridge, normalization and lazy execution + +Files: `src/blosc2/portable_kernel.py`, `dsl_kernel.py`, `blosc2_ext.pyx` and +associated native declarations, `lazyexpr.py`. + +1. Make export/validation APIs default to draft 1.0; reject retired versions. + select 1.0 explicitly for new persistence until the public-default transition + is documented. Import remains native-only. +2. Reuse NumPy-call, string-syntax and static-row normalization; record named + column bindings and snapshot supported typed constants, including strings. + Reject opaque captures without invoking arbitrary conversion hooks. +3. Pass context, width, shape/cardinality and evaluation errors through Cython. + Extend `PortableKernel.evaluate()` accordingly. Build interpreter-backed lazy + execution around the native handle, not around `kernel_from_source()` or exec. +4. Define a persisted logical block grid with shape, block extents, domain origin + and C-order traversal. Bind it once for reduction-bearing kernels; do not + derive it anew from current physical chunks at each evaluation. +5. Schedule complete original reduction groups for elementwise partial reads; + gather/scatter across physical storage as necessary. Elementwise-only kernels + may be tiled freely while retaining original logical ND coordinates. +6. Implement the approved block-scalar output mapping and distinguish input + domain shape from result shape. Validate immutable bound dtypes/widths and + domain requirements when reopening referenced operands. +7. Preserve author-written compiler pragmas as compiler selection preferences; + local defaults must not override them. They do not exempt the backend from + portable semantic checks or disable the agreed interpreter fallback. + +Exit: ND/string/reduction kernels run lazily through native handles, with slice +results and reduction grouping unchanged after storage rechunking. + +## 8. Enforce portable-only kernel persistence end to end + +Files: `b2objects.py`, `lazyexpr.py`, `deserialization.py`, relevant open/from-frame +entry points and CTable computed/generated-column serializers. + +1. Trace every DSL-kernel save/load route: structured B2Objects, older LazyUDF + metadata paths, embedded/nested lazy operands, CTable columns and frames. + Use one encoder/validator and one native decoder rather than divergent formats. +2. Preflight normalized kernel portability and typed bindings before creating or + replacing the destination. Save the artifact plus explicit operand references, + logical context/partition and container format discriminator. +3. Remove broad exception-driven fallback to source-based persistence for DSL + kernels. A portability failure must survive to the caller with location/reason. + Do not redefine ordinary non-kernel LazyExpr persistence by accident. +4. On load, distinguish portable, legacy and malformed records using metadata + only. Validate portable artifacts natively before binding/execution; never + reconstruct Python from a portable record, even after validation fails. +5. Apply explicit legacy opt-in consistently, including recursive operands. + Review current hard-coded `deserialize="full"` calls in `b2objects.py` and + effective defaults in `deserialization.py`; do not allow an internal reopen + to bypass the user's selected policy. +6. No automatic migration, conversion command or source-rewrite-on-open. + Document manual changes and explicit legacy use. Container/data-source + portability is separate from standalone kernel portability; demonstrate C + execution of the stored artifact with supplied bindings, without promising + C support for every Python remote/container protocol. + +Exit: all new DSL save routes reject excluded features; round trips preserve +native-only execution and block context; legacy files require opt-in everywhere. + +## 9. Optional JIT eligibility, not a JIT implementation project + +After interpreter milestones, build a conservative eligibility predicate over +the typed program and backend capabilities. Its default answer is no. + +- Allow only operation/type/context combinations already shown to implement 1.0 + semantics. Include semantic version, dtype/width and relevant policy in cache + identity so cached full-DSL programs cannot masquerade as 1.0 programs. +- Keep checked integers, unsupported casts, strings, ND/reduction combinations + and uncertain masking on the interpreter until individually certified. +- Optional JIT unavailability or unsupported lowering selects interpreter before + execution. Do not retry an executed, failing kernel using another backend; + arithmetic/domain failures remain failures. +- Required-JIT remains an explicit host diagnostic mode: report unsupported + acceleration instead of falsely claiming JIT execution. +- Retain the Windows interpreter baseline and WASM exact-integer fallback. + No target is required to acquire a new code generator for 1.0. + +Exit: eligible kernels match interpreter semantics; ineligible kernels execute +correctly by default and report a reason when JIT is explicitly required. + +## 10. Bounded conformance and integration verification + +Do not cross-product dtype, operation, backend, length and storage dimensions. +Put the detailed semantic corpus in miniexpr and keep approximately 100–200 +orthogonal Python portable tests, restructuring existing cases as necessary. + +Native fixtures cover exact boundary/error cases for each checked operation; +representative promotion/literal pairs; rounding and inactive-lane behavior; +Mandelbrot and masked reductions; ND origins/padding; string encodings/widths; +artifact errors, capacity and ownership; immutable concurrent handles. + +Python integration covers normalization and captures, standalone-native import, +native error propagation, each save route, legacy opt-in, rejection without +partial destination replacement, partial reads/rechunking, scalar-block shapes, +default fallback and explicit required-JIT failure. Use exact expected values +for integers rather than a NumPy overflow reference. Floating expectations use +the specified rounding/order or function-specific tolerance. + +Normal Python tests use the published/pinned miniexpr and self-contained fixtures. +Keep external corpus/C-runner checks opt-in through the established environment +variables; never infer a sibling checkout at runtime. + +Run targeted tests after each milestone, native sanitizers for masks/capacity/ +arithmetic, then full native/Python CI including Windows and WASM at integration. +Use the `blosc2` conda environment for Python, builds and tests. Smoke-test an +isolated wheel built without local native overrides. Test artifact-disabled +builds report missing capability cleanly. Update the published native pin only +after the required native code is available; no unpublished-checkout dependency. + +## Delivery order and completion checklist + +### Autonomous execution and durable handoff + +Follow the milestones in order, recording progress and verification after each. +The autonomous implementation target is completion of the beta-readiness gates, +not collection of external beta feedback or automatic freezing of the contract. + +- Repository scope covers the necessary changes in Python-Blosc2 and miniexpr. + Follow each repository's local instructions. Preserve unrelated user work; + avoid unrelated refactors and whole-language JIT audits. +- Prioritize interpreter correctness and use pre-execution JIT fallback. Do not + spend a milestone's effort implementing optional acceleration. +- Continue through routine implementation, build and test failures without + asking permission. Resolve ordinary details from approved semantics, verified + implementation behavior and the normative matrix. +- Pause only for unresolved semantic decisions, scope contradictions or external + blockers such as unavailable credentials. Record the precise blocker and + proposed resolution; continue independent unblocked milestones where possible. +- Commits, pushes, publishing and other repository/release state changes require + explicit user authorization consistent with repository instructions. This plan + does not itself grant those permissions. Run available local verification; + record any CI checks blocked by missing authorization or credentials. +- Keep a durable handoff in `plans/portable-DSL-1.0-progress.md`. Create it at the + start of implementation and update it after every milestone and before any + interruption or context handoff. Include completed checklist items, changed + files in both repositories, exact verification commands/results, unresolved + failures, decisions and their approval status, and the next concrete action. + Record relevant native revision/build/pin information so another session can + reproduce the environment. Do not store credentials or secrets. +- On resume, read this plan, the scope agreement, the progress file and current + working-tree changes before editing. Do not assume an interrupted command + completed or discard partial work. Reverify uncertain results. +- At completion, summarize delivered behavior and remaining external release + gates. Do not claim CI success, beta feedback or release publication without + evidence. + +Checklist status is **local implementation**, not release/platform certification; +authoritative commands/results are in `portable-DSL-1.0-progress.md`. + +1. [x] Finish finite normative draft type/arity/domain/tie/NaN/reduction/Unicode + matrix (Q1–Q3 confirmed), with analytic/exact-reference fixtures. Independent + function-specific cross-platform libm accuracy bounds remain a release gate. +2. [x] Add versioned compilation/interpreter-only 1.0 dispatch, including public + core-only source validation and extended ND/cardinality/string-width descriptor. +3. [x] Complete checked operand-typed numeric semantics and active-lane errors. +4. [x] Complete reduction masks/cardinality, including rejection of divergent + scalar return sites and preservation of finished-lane iterator values. +5. [x] Extend artifact ABI/schema/context and native runner/descriptor fixtures. +6. [x] Admit bounded fixed strings and logical ND descriptors through native code. +7. [x] Integrate Python native handles and immutable logical-block scheduling. +8. [x] Enforce validated saves/native loads and recursive explicit legacy opt-in + across the implemented disk/frame/container/table routes, with safe MessagePack + defaults. No source fallback; table row-domain modes are explicit. + New authored DSLKernel-backed LazyUDF saves automatically normalize and export + validated 1.0 artifacts, with typed scalar/capture snapshots and named array + bindings. Preserve the elementwise domain and current uniform logical block + grid; reject true block-scalar kernels with explicit portable API guidance. + This is authoring preflight, not automatic migration of loaded legacy carriers. + Explicit independent-row table APIs accept DSLKernel authoring plus output + dtype/cardinality directly; old vector-column APIs have no row-domain contract + and reject persistence with a specific ambiguity diagnostic. +9. [x] Conservative interpreter-only dispatch and pre-execution optional JIT + fallback; required-JIT rejects unsupported acceleration explicitly. +10. [x] Complete release verification gates for the tested platform matrix: + - [x] Compact local Python/native conformance and full local ASAN/UBSAN. + - [x] Isolated native-development override wheels and artifact-disabled smoke. + - [x] Draft/API docs build; changed portable page free of diagnostics. + - [x] Native Windows/Linux/macOS/WASM conformance matrix (all seven jobs green). + - [x] Independent finite math corpus and stock-pin macOS execution: 284 samples, + 40 canonical operations, both floating precisions, function-specific budgets. + - [x] Execute the independent math corpus on remaining Python release platforms + (no universal ULP bound inferred from the finite corpus or host libm). + - [x] Publish/pin the native revision and verify a stock-pin macOS ARM64 wheel. + - [x] Complete the remaining stock-pin platform wheel matrix (27 successful jobs; + retain the existing untested macOS Intel cp315/cp315t dependency exception). + - [x] Whole-tree docs disposition: fix parsing errors, exclude generated input + trees, and inventory/defer existing image/reference warnings outside Menudet. + +Each step must land as a usable tested increment; reduction and string fixtures +can be prepared while numeric interpretation is implemented, without introducing +unapproved semantics. If a useful existing feature cannot fit the finite matrix, +raise the specific incompatibility rather than silently shrinking scope. + +Release documentation includes normative native specs, Python API/persistence +guidelines, manual legacy adaptation, standalone C examples, and corrected DSL +reference statements. These checks establish readiness for the beta milestone +below; freezing the public 1.0 contract additionally requires beta feedback. +Do not tie completion to broad JIT acceleration, migration utilities or new +remote-storage protocols. + +## Release milestone: miniexpr beta and portable 1.0 release candidate + +Once the implementation checklist passes, move miniexpr into beta with portable +DSL 1.0 as a **release-candidate specification**. Interpreter conformance across +supported platforms, native artifact loading, and working persistence integration +are the entry gates. Limited JIT coverage does not block beta: correct +pre-execution interpreter fallback is sufficient. + +Keep the two release promises distinct: + +- **Miniexpr beta:** implementation and APIs are approaching release readiness; + broader use should exercise integration, usability and performance. +- **Portable DSL 1.0, once frozen:** a public compatibility commitment independent + of whether the miniexpr implementation is still in beta. + +During beta, exercise real persisted kernels and cross-language C/Python loading, +including ND context, fixed-width strings, block reductions, partial reads and +legacy opt-in. Resolve contract ambiguities and compatibility issues found in +that feedback before freezing 1.0. Clearly label release-candidate artifacts and +their compatibility status; do not present draft artifacts as already covered +by the final 1.0 guarantee. + +- [ ] Enter miniexpr beta after the implementation and verification gates pass. +- [ ] Publish portable 1.0 as a release-candidate specification during beta. +- [ ] Review real-world persistence and cross-language feedback; resolve blockers. +- [ ] Freeze and publish the portable 1.0 compatibility contract after that review. + +Further JIT acceleration remains an independent optimization, not a prerequisite +for either beta entry or contract freeze. diff --git a/plans/portable-DSL-1.0-progress.md b/plans/portable-DSL-1.0-progress.md new file mode 100644 index 000000000..42a46092f --- /dev/null +++ b/plans/portable-DSL-1.0-progress.md @@ -0,0 +1,1352 @@ +# Portable DSL 1.0 implementation progress + +## Table API and LazyExpr compatibility follow-up + +The user approved unifying table kernel registration and restoring ordinary +LazyExpr persistence, then explicitly requested **no `add_portable_*` aliases**. +The final policy retains trusted legacy execution through explicit +`deserialize="full"`; it supersedes the briefly proposed unconditional rejection. + +- `add_computed_column()` / `add_generated_column()` now export and validate + authored kernels and accept native artifacts with named bindings. Positional + lists and column-bound DSL LazyUDFs adopt the same independent-row contract. + `assign()` uses the same normalization; new registrations have no vector-column + fallback. String/lazy expressions and non-kernel row transformers are unchanged. +- Removed the separate portable-column methods and public `row_domain` argument. + New metadata omits `row_domain`; prior draft metadata with the independent + marker still validates, and unknown grouping markers reject. Fixed-shape row + reductions use `cardinality="block_scalar"`. +- Safe loading rejects legacy table-column recipes before source reconstruction, + with an explicit message naming block/batch-dependent behavior and the trusted + `"full"` opt-in. Full loading preserves legacy execution, not reinterpretation. +- Removed the new arithmetic-only LazyExpr AST restriction. Existing expression + validation remains. Ordinary numerical-expression round-trip tests now reopen + with the default policy; nested legacy/proxy/other full-only payloads stay gated. +- Added default round trips for `sqrt(x)`, `sum(x)`, `x.mean()` and `x[0]`, row-local + reduction tests, persisted legacy computed/generated opt-in tests, and artifact + registration/no-mutation checks. Updated API docs, release notes and example. + +Verification and final CI run links are recorded below as they complete. Earlier +sections describe the original API and are historical where they differ here. + +Local verification: the full default suite (including module doctests) passed +**11,291 cases**, with 55 existing skips. All 284 independent math samples passed, the Menudet +example ran, and Ruff/format/whitespace checks passed. Sphinx completed with no +ERROR diagnostics or warnings on the modified Menudet/persistence pages; the +previous unrelated whole-tree warnings remain outside this change. + +## Published release certification — green platform matrix + +The user authorized publishing changes and monitoring/fixing CI until green. +Native Menudet documentation was published as miniexpr +`36770f87e10f1b92bfe0f9f92a7039eba2e976ea`; all seven native jobs passed in +[37618199852](https://github.com/Blosc/miniexpr/actions/runs/37618199852). +Python still pins the already-green runtime revision `3418cdce...`: the subsequent +native changes are documentation/matrix metadata only, not runtime changes. + +Python release-hardening and certification fixes are published on `portable-dsls`. +Certified implementation/workflow revision: +`e768bc538cb096c7f5c669046ed3aed5e55d9c6b`. Successful runs: + +- [Tests 37622410469](https://github.com/Blosc/python-blosc2/actions/runs/37622410469) + — all standard platform jobs green, including independent math reports. +- [WASM 37622410514](https://github.com/Blosc/python-blosc2/actions/runs/37622410514) + — Python/Pyodide suite plus the independent corpus green. +- [Python wheels 37622420247](https://github.com/Blosc/python-blosc2/actions/runs/37622420247) + — **27 successful jobs**: seven native/WASM build jobs and twenty abi3 test + jobs across Python 3.11–3.15. Includes Linux x64/ARM64, Windows x64/ARM64, + macOS x64/ARM64, Pyodide 3.13/3.14 and free-threaded builds. PyPI upload is + intentionally skipped (no tag/publication). The pre-existing skip of testing + macOS Intel cp315/cp315t wheels is retained for unavailable pre-release dependency + wheels; do not claim those specific wheels were tested. + +The first two wheel runs (`37618308296`, `37620050340`) failed because importing +the extension safely enables the GIL on free-threaded Python, emitting a +RuntimeWarning that pytest promoted to an error. A command-line filter initially +failed because pytest treats CLI warning messages literally, not as regexes. +Moved the **exact extension-specific regex** into `pytest.ini`; other runtime +warnings remain errors. A local synthetic check confirms both acceptance of the +expected import warning and rejection of an unrelated numeric RuntimeWarning. +No `PYTHON_GIL=0`, no no-GIL safety declaration, no tolerance changes or new +conformance skips were introduced. + +Added `workflow_dispatch` to the wheel workflow to certify development revisions +without release tags. Both wheel Pyodide versions and each abi3 matrix job now +also run the independent corpus. + +Downloaded and verified all five native Python math reports: every report has +**284 samples and zero failures**. Maximum observed ULP: Windows **2**, Linux +**2** (including NumPy 1.26 and Python 3.14 jobs), macOS ARM64 **3**. Reports are +under `/menudet-native-ci-math-reports`. Wheel/WASM corpus executions +are additionally certified by the successful corresponding job commands. + +The earlier external-platform/published-branch blockers below are superseded. +Release certification for the tested matrix is now green; final release version, +publication, beta feedback and compatibility freeze remain separate decisions. + +## Menudet / 4.15.0 release hardening — current handoff + +The user selected **Menudet — a little language for portable computation on +arrays and tables**, and approved the release-hardening plan. Menudet is the +portable language; miniexpr implements it. Existing API/format identifiers remain +unchanged. Broader JIT acceleration is deliberately separate: the native guard +still forces portable interpretation, preserving checked/ordered semantics. + +### Delivered in this increment + +- Both version fields now read `4.15.0.dev0` (development, not final publication). +- Python reference, release notes and native spec introductions name Menudet, + retain the draft warning, and distinguish full DSL from portable semantics. +- `examples/menudet.py` demonstrates the same array/table kernel plus explicit + logical block-scalar reductions; assertions passed against the installed wheel. +- Added `scripts/certify_menudet_math.py` and its checked-in JSON corpus: **284 + samples, 40 canonical functions, float32 and float64**, generated with mpmath + 1.3.0 at 100/200 decimal digits. Regeneration equality and deliberate failure + detection passed. No new runtime dependency; mpmath is needed only to regenerate. +- Function-specific finite sample budgets and coverage limitations are documented + in `doc/reference/menudet_accuracy.md`. These are not universal ULP guarantees + or certification of all possible inputs. Native exceptional/exact/alias fixtures + remain required. +- Wired the corpus into native Python, WASM and installed-wheel CI. Native jobs + upload platform reports; tested wheels also execute the seven portable modules. + +### Verification + +All Python/build commands used conda `blosc2`. Fresh stock build fetched native +`3418cdce4b5c11e1661c8b6453e3d31d94b0b2b4`; both source override cache entries +are empty. Isolated imports asserted the installed target path and excluded the +editable finder only within the test subprocess. + +- Working-tree stock wheel: **11160 tests passed, 53 skips** (excluding heavy, + network and TUI), plus **120 installed-module doctests passed, 2 skips** in a + clean working directory. The serial combined invocation initially encountered + one relative-filename save failure: installed doctest modules are outside the + repository root fixture's isolation. All tests passed, and all doctests passed + on the clean-directory rerun; no user's existing file was removed to fix it. +- Independent corpus on that wheel: **284 passed**, maximum observed error + **3 ULP** (lgamma/float64); no tolerance changed after observing results. +- Built an **8,044,023-byte clean sdist**, verified inclusion of checker, corpus + and example, built a wheel from the unpacked sdist, and isolated-installed it. + This wheel passed **183 portable tests, 17 explicit external opt-in skips**, + plus all **284 independent math samples**. +- Clean-sdist wheel SHA256: + `c7fcc99d44fe12a7cdffc717eff4bc04450954c6d51eb98b282d09c2646b0d67`. +- Clean snapshot copied only tracked files and the four requested new files; + unrelated untracked local work was neither packaged nor deleted. A direct + dirty-checkout sdist attempt timed out and is not a release artifact. +- Ruff, format, workflow YAML, reference regeneration and whitespace checks pass. + +### Documentation disposition + +Fixed installation list-table indentation, stopped treating generated `doc/html` +and autosummary stash trees as sources, and documented NumPy's finfo alias without +reparsing its incompatible nested sections. Documented deserialization policy +types/errors and taught the public-API tripwire to recognize manual `py:class`. +Fresh whole-tree Sphinx now has **zero ERROR diagnostics**, and no Menudet page +diagnostic. It still has existing non-Menudet warnings: the fresh build reported +769 (639 autosummary stub, 100 duplicate object/label, 11 ambiguous references, +2 image, 17 other); the final follow-up with notebook execution disabled reports +772, with no undocumented-finfo warning. They remain visible, unsuppressed +documentation backlog, not a claim of a warnings-as-errors clean build. Menudet +pages and parser errors are the scope of this draft's documentation acceptance; +broad autosummary/reference cleanup is explicitly deferred. + +### External gates still pending + +The updated Python branch/workflows are not remotely available, so no new Python +platform job can certify these changes yet. Native miniexpr's seven-job matrix +is already green, but it does not certify Python artifacts/wheels. Windows, +Linux, Pyodide, free-threaded/ABI/platform wheel jobs must run the updated corpus +and integration tests and resolve any failures before releasing. No release or +beta publication occurred; final version metadata waits for those gates. + +Temporary directories under the approved temp root: `menudet-release-build`, +`menudet-release-wheel`, `menudet-release-installed`, `menudet-release-snapshot`, +`menudet-clean-sdist`, `menudet-sdist-unpacked`, `menudet-sdist-wheel`, +`menudet-sdist-installed`, `menudet-release-docs-clean`, and +`menudet-release-doctrees-clean`. Reports: `menudet-math-macos.json` and +`menudet-sdist-math-macos.json`. + +## Dependency pin updated after green native CI + +At the user's request, `CMakeLists.txt` now pins the green native revision +`3418cdce4b5c11e1661c8b6453e3d31d94b0b2b4` from CI run `37612064807`. +Earlier notes saying the Python pin remains at `55c882b` are superseded. +Stock Python wheels have not yet been rebuilt/tested against this updated pin. + +## Native CI green (supersedes investigation below) + +At the user's request, published the fixes and monitored/repaired CI until green. +Revision `02791f338a853af517b6fedbd38c18d5a2b8da1a` fixed WASM and Windows +builtin recognition, but run `37611459450` exposed a second Windows issue: +identical-code folding merged the floating cast callback with real/conj identity +callbacks, misclassifying their output type. A unique volatile read in the cast +callback preserves its address identity without altering signed zero or NaNs. +The anchor fixture now reports the source and dtypes on a type mismatch. + +Final published revision: `3418cdce4b5c11e1661c8b6453e3d31d94b0b2b4`. +CI run [37612064807](https://github.com/Blosc/miniexpr/actions/runs/37612064807) +completed **successfully: all seven jobs green**, including Windows x64/ARM64, +Linux x64, Linux ARM64 interpreter/JIT, macOS, and WASM (including side-module +helper and JIT trace checks). Targeted local portable interpreter test also passed +after the cast-identity repair. Python's dependency pin remains at `55c882b`; +this entry does not claim Python stock-wheel certification of the final fixes. + +## Native CI failure investigation (2026-10-07) + +CI run `37610312891` on native revision `55c882b` failed on Windows x64, +Windows ARM64, and WASM. Both Windows failures occur while compiling the portable +`hypot(x, 2.0)` fixture: libm address recognition fails. WASM compilation fails +because its fenv lacks `FE_INVALID`; the new test also incorrectly assumed host +rounding/thread facilities. + +Local fixes in miniexpr: + +- `src/functions.c`: typed builtin recognition also matches the exact builtin + registration address, handling CRT inline/import aliases such as Windows hypot. +- `tests/test_dsl_portable_interp.c`: WASM retains numeric/literal/environment + checks under its fixed nearest rounding, without requiring unavailable exception + flags or pthreads. Native upward-rounding, exception and concurrency checks stay. + +Verification: complete native interpreter suite **325 passed**; local Emscripten +interpreter-only suite **48 passed**; CI-style WASM with JIT enabled **50 passed**; +targeted native portable interpreter ASAN/UBSAN **passed**. Existing duplicate +library and warning-enabled unused-function warnings remain; no WASM build warning +was observed. Remote Windows jobs still require revalidation with these fixes; +the reported failed CI run is not claimed green. Published pin is unchanged. + +Build directories: `/miniexpr-portable-1-interpreter`, +`/miniexpr-portable-1-wasm-fix`, and +`/miniexpr-portable-1-sanitized`. WASM was configured with `emcmake`, +Node as emulator, SLEEF OFF, then TCC JIT ON/bundled host TCC OFF/trace ON to match +the CI configuration. All commands used `conda run -n blosc2`. + +## Published dependency update — latest status + +The user authorized committing/pushing miniexpr and committing the Python +implementation plus dependency pin. Native implementation is published on +`Blosc/miniexpr` main at `55c882b238c4daf0523a52a44d5d84db56af24e4`. +Python-Blosc2 `CMakeLists.txt` pins that exact revision. Earlier notes saying the +published pin is unchanged are historical and superseded by this update. + +A fresh stock wheel (no local source overrides) built successfully using that +revision. Both `FETCHCONTENT_SOURCE_DIR_MINIEXPR` and +`FETCHCONTENT_SOURCE_DIR_BLOSC2` are empty in its CMake cache, and the fetched +native checkout reports the pinned SHA. The isolated installed wheel passed all +seven portable test modules: **183 passed, 17 external opt-in skips** (200 cases). +The editable development installation was not replaced. + +Verification commands used `conda run -n blosc2 python -m pip wheel . --no-deps +--no-build-isolation --wheel-dir /portable-1-published-pin-wheel +--config-settings=build-dir=/portable-1-published-pin-build`, followed +by a separate `pip install --no-deps --target /portable-1-published-pin-smoke` +and pytest with the editable finder excluded only in that subprocess. Wheel SHA256: +`434b4cb6fdb1e5fa11dd088a749a42359ed798242e8de05cef69710d642c9d87`. + +This verifies the published-pin macOS ARM64 wheel, not Linux/Windows/WASM +certification or beta readiness. Unrelated user work remains unstaged. + +## CURRENT STATUS — authoritative handoff (supersedes all older sections below) + +### Unreleased portable 0.1 retired; draft 1.0 is the public default (2026-10-07) + +The user's corrected release scope is implemented in both repositories. Portable +0.1 was never released and has no compatibility obligation. The public story is +experimental/draft portable 1.0 versus legacy Python-specific persistence, whose +active reconstruction requires explicit `deserialize='full'`. No automatic +migration or reinterpretation occurs. Ordinary full-DSL semantics are unchanged. + +- `DSLKernel.export`, its authoring helper and `validate_portable_dsl` default to + 1.0. Removed the Python 0.1 dtype/call allowlists, scalar encoder and export + branch. Old native builds report unavailable draft support instead of exposing + their retired loader; the published native pin remains unchanged. +- Native `dsl_portable.c` now contains only typed draft validation. The artifact + loader rejects unsupported schema/language versions before interpreting their + envelope as 1.0, then strictly validates context/signature/capabilities/constants. + Removed the old source filter, full-profile artifact compilation, tiled evaluator + state and mask/ND rejection branch. `me_artifact_eval` remains a useful rank-zero + numeric elementwise call adapter to descriptor evaluation, not format support. +- Portable compilation no longer inherits full-DSL `ME_DSL_FP_MODE` defaults; + it uses the strict parsed draft default and still rejects explicit non-strict + source. Ordinary full-DSL environment policy remains intact. +- Removed obsolete freeze/language/artifact draft documents and the 18-entry + frozen-excluded manifest/category/rejection tests. Retargeted the native corpus + and runners to interpreter-first 1.0. Separate full-DSL audit cases remain. + Five corpus reference files now reflect operand-driven float32 arithmetic, + explicit float64 casts and integral Boolean-negation zero, rather than output + context typing. Native encoding, schema, ownership, binding and descriptor + regressions remain and now load 1.0. +- The Python host suite retargets the former frozen boundary to actual arithmetic + admission/results and checked overflow, preserving all 200 orthogonal cases. + Mixed captures and NumPy normalization now execute; the old rejected string + capture case now verifies a typed Unicode snapshot. Optional JIT requests always + assert interpreter fallback, never pretend `has_jit=True`. External corpus/runner + tests use explicit environment paths only and now exercise portable artifacts. +- User-facing Python/native API docs and specifications describe draft 1.0 only, + with a prominent experimental notice and no invented beta/platform claim. + Implementation plan/scope current decisions record retirement. Historical + verification below and unrelated user files/logs are retained. + +Verification so far, all commands in conda `blosc2`: + +- Complete native CTest: **325 passed**; complete ASAN+UBSAN CTest: **325 passed**. + The count drops from 343 solely because the 18 obsolete frozen rejection gates + were removed; useful arithmetic/masking/encoding/validation fixtures remain. +- Seven portable Python modules: **183 passed, 17 external skips = 200 cases**. + Explicit external native corpus/runner integration: **176 passed, zero skips** + across `test_portable_artifact.py` and `test_dsl_portable.py`. +- Full default Python suite: **11280 passed, 55 skipped**, 36.35s, after the final + bridge/validator changes and retained Unicode capture regression. +- Native warning-enabled rebuild retains existing unused helpers/aggregate + initializers/unknown SIMD pragmas and duplicate-library linker warnings. No new + warning in the retirement validator/artifact/runner changes or sanitizer finding. + +Remaining release gates are unchanged: independent function/platform accuracy, +Windows/Linux/WASM and stock-published-pin wheel certification, authorized native +publication/pin update, and clean whole-tree documentation. Local development +override wheel results are not stock-published-pin evidence. + +### Final retirement verification and file handoff + +- Rebuilt editable extension with explicit local miniexpr and C-Blosc2 overrides. + After isolated wheel installs, rechecked source import path and active descriptor + support; the editable install remains in use. Published pin/dependencies unchanged. +- Isolated local-native-override wheel: all seven portable modules **183 passed, + 17 external skips**, 1.80s. Smoke subprocess removed only its own editable finder, + asserted the imported package was beneath its isolated target and used `-n 0`. + Wheel SHA256 `16a514a8063601c4a4eb1ce1ebfe1a0b13e1421c8e4cbb1e32126424127c290f`. + This is not stock-published-pin, platform or published-wheel certification. +- Separate artifact-disabled local-override wheel built/installed only to another + isolated target. Ordinary array arithmetic and draft numeric/string/ND source + validation pass; retired source version rejects and artifact loading explicitly + reports `NotImplementedError`. No installed editable replacement. +- Final native and ASAN+UBSAN suites: **325/325** each, 9.08s / 9.23s. Final + incremental builds report only the existing duplicate `-lm`/static-library + linker warning; no sanitizer error. Earlier warning-enabled full rebuild retains + the pre-existing warnings documented above, not a warning-free whole-tree claim. +- Ruff lint and format checks pass on all four Python files changed by retirement; + Cython compiled successfully in editable and both wheel builds. Both repositories + pass `git diff --check`. +- Sphinx exits successfully; neither changed portable/native-syntax Python page has + a diagnostic. Whole-tree output contains **931 WARNING / 4 ERROR lines**, including + existing installation list-table, NumPy/reference/image/generated-stub issues. + This remains an incomplete clean docs gate, not a release acceptance claim. +- Final callsite/version audit over source/tests/docs/examples/build/CI files finds + no retired portable support/default/freeze links; explicit 0.1 rejection tests + and numeric literals remain. Moved the prior numeric audit to + `../miniexpr/plans/numeric-audit-0.1-history.md` as a factual archive, out of public + specifications. Unrelated untracked user work and user logs are untouched. +- Final additive regression verifies an actual retired envelope (no `context`, + `core-scalar`, `scalar-per-element`) rejects specifically as unsupported version, + not as malformed 1.0. The containing diagnostics case reran **1 passed**; + lint/format and both whitespace checks passed again. No extra test-count grid. + +Retirement files (in addition to preserved earlier 1.0 implementation): + +- Python: `src/blosc2/dsl_kernel.py`, `portable_kernel.py`, `blosc2_ext.pyx`, + `dsl_artifact_bridge.h`; `tests/test_portable_artifact.py`, `test_dsl_portable.py`; + `doc/reference/portable_dsl.rst`, `dsl_syntax.md`; current plan, scope and progress. +- Native: `src/dsl_portable.c`, `dsl_artifact.c`, `dsl_compile.c`, `miniexpr.h`, + `miniexpr_artifact.h`, `dsl_portable_types.h`, `functions.c`; + `tests/CMakeLists.txt`, `test_dsl_portable_validation.c`, `test_dsl_artifact.c`; + both portable runner/README directories, affine JSON and five arithmetic/Boolean + reference fixtures; draft 1.0 specs and native DSL syntax/usage docs. + Removed `doc/dsl-spec/{0.1,artifact-0.1,draft-history-0.1}.md` and + `tests/portable-dsl/frozen-excluded.txt`; preserved historical numeric audit as above. +- Reproducible logs/builds/wheels are under the approved temporary root with + `retire-` prefix: editable, full/target/external Python, native/sanitized builds + and tests, wheel build/install/tests, disabled build/install/smoke and docs. + +## PRIOR IMPLEMENTATION HANDOFF — historical; superseded by retirement above + +Final parent-session check: the seven portable Python modules passed again +(**183 passed, 17 external skips**, 200 cases); whitespace checks passed in both +repositories. Local implementation milestones 1–9 are complete as recorded in +the implementation checklist. Remaining milestone 10 gates are external release +certification and pre-existing whole-tree documentation issues, not a claim that +miniexpr has entered beta or portable 1.0 is frozen. + +- Parent scope correction implemented: compliant newly authored DSLKernel-backed + LazyUDF saves/frames/stores/MessagePack/nested references now automatically + normalize and export validated native 1.0 recipes. Blanket rejection was too + strict and is removed. Shared `portable_from_lazyudf` preflight preserves typed + captures/scalar bindings, parameter-named array refs, output domain and existing + uniform logical block partitions. Block-scalar return/elementwise shape conflicts + reject with explicit `PortableKernel.lazy` guidance; chunk boundaries that split + that uniform block grid reject rather than inventing grouping. Loaded legacy + recipes are marked and remain nonmigrating, explicitly full-policy-only on load. +- CTable independent-row APIs accept DSLKernel authors directly with explicit + output dtype and reduction cardinality; authoring validates before registration. + Old vector-column APIs remain ambiguous about row-domain/grouping and now report + this specific reason and the usable authored independent-row route. Restored + add-square/loop/where/object/table roundtrips replace obsolete blanket-rejection + tests. Unsupported effect/callback and legacy saves preserve destinations. + Latest scope-correction verification: **11280 Python / 343 native / 343 + ASAN+UBSAN**, isolated development wheel **458 passed, 17 external skips**. + The compact portable boundary is unchanged at **200 cases**. Details below. +- Public validation closure is now implemented: core `me_validate_portable_dsl` + explicitly dispatches 1.0; new `me_validate_portable_dsl_ex` carries exact string + output width, logical ND rank and asserted/inferred cardinality. It uses the + existing profile parser/compiler with JIT OFF and no input buffers/callbacks, + execution, Python reconstruction or optional yyjson/artifact dependency. + Python `validate_portable_dsl(..., language_version='1.0', ndim=..., + cardinality=...)` routes to that API, preserving frozen 0.1 and reporting native + status/source locations. Actual local editable extension was rebuilt. +- The finite 1.0 matrix/spec now has normative draft arities/types, checked + combinatoric domains/width limits, ~ semantics, rounding/ties, NaN/zero rules, + ordered/empty/coherent reductions, Unicode 15.0.0 case data/exact whitespace + sets and string index/width rules. Independent analytic/hexadecimal references, + adjacent float steps, exact fused cancellation, all integer factorial limits, + canonical/alias math and explicit exceptional-value fixtures supplement—not + replace—the older same-host libm regression matrix. No universal accuracy + bound or external platform certification is invented. Implementation checklist + now distinguishes completed local milestones 1–9 from specific release gates. +- Independent correctness review found and fixed two boundary bugs (finished-loop + lane iterator clobbering and NumPy signed-minimum capture conversion warnings). + Post-review suites still pass: **11280 Python / 343 native / 343 ASAN+UBSAN**; + portable boundary remains **200 cases (183 passed, 17 external skips)**. + Both surfaced contract concerns are now **resolved**: typed structural validation + rejects divergent block-scalar returns as ambiguous output, preserving coherent + scalar control flow; MessagePack defaults to safe with explicit recursive caller + policy propagation. Post-fix isolated native-override wheel also passes the + entire 200-case portable boundary. See contract-follow-up addendum below. +- Installed conda `blosc2` editable extension uses the explicit local miniexpr + development override. Published native pin is unchanged. Local 1.0 tests run, + not skip. No commits, publishing or external platform certification performed. +- Native typed interpreter, draft schema/signature/constants, fixed strings, + ND descriptors, masked reductions, logical lazy partitions, partial reads, + streaming output/rechunking and safe portable persistence are connected. +- Added explicit independent-row CTable native computed/generated APIs: + `add_portable_computed_column` and `add_portable_generated_column`, requiring + `row_domain='independent'`. Each row is an original one-lane group; ND shape + (1,), origin (0,) are row-local, not global table indices. Append, refresh, + deletion and compacted save do not change these semantics. Fixed-shape ndarray + row inputs now also support scalar native reductions, with scalar/array input + broadcasting inside the complete row group, persisted immutable row shapes and + zero row-local ND origin. Table records carry artifact JSON, bindings and + row-domain metadata and load natively, never Python functions. Multi-row table + partitions/vector-valued output modes are explicitly unsupported; the native + standalone/lazy APIs still support the full logical-partition contract. +- Added explicit `DSLKernel.export(..., version='1.0', cardinality=..., ndim=...)`. + Reuses existing static row/string/NumPy call normalization and capture token + parameterization; typed signed/unsigned/float/byte/Unicode snapshots. Native + load validates normalized source and output widths/cardinality before export + succeeds. Default export remains frozen 0.1; no migration on import. +- Full default Python suite after resolving persistence regressions and a real + carrierless RemoteArray policy bug: **11280 passed, 55 skipped**. The policy + helper now handles objects whose `schunk` is None without losing effective + recursive policy. Previously failing old new-save expectations now verify + rejection of noncompliant kernels before destination writes; compliant authored + save roundtrips were restored by the parent scope correction above. Old + explicit-full load fixtures remain. +- Local native-development wheel built and isolated import/native reduction smoke + passed, explicitly **not a stock published-pin wheel result**. Artifact-disabled + development wheel built and isolated ordinary arithmetic/missing-loader smoke + passed. Editable install was not replaced by either isolated wheel install. +- Added finite native float32/float64 operation result-type/domain fixtures for + 26 numeric libm operations and six exceptional domains. These compare host + libm within explicit 8-epsilon relative bounds; independent cross-platform ULP + certification is still an external release-matrix gate, not claimed complete. + +Current changed inventory (including preserved earlier edits): native sources/tests +and draft specs listed in historical inventory below; Python bridge +`blosc2_ext.pyx`, `dsl_artifact_bridge.h`, `portable_kernel.py`, `portable_lazy.py`, +`dsl_kernel.py`, `ctable.py`, `deserialization.py`, `b2objects.py`, `lazyexpr.py`, +`schunk.py`, `core.py`, `ndarray.py`, `msgpack_utils.py`, `embed_store.py`, +`dict_store.py`, `tree_store.py`; `doc/reference/portable_dsl.rst`; portable tests, +legacy policy/persistence tests and affected table/ndarray/objectarray tests. +Most recent native closure: `src/dsl_portable.c`, `src/miniexpr.h`, and the +public-validation/independent-reference test functions. Keep unrelated user +files and all existing uncommitted changes. + +Table-copy/materialization and native signature/shape/dependency revalidation on +save and load are now implemented. Executed fixtures include static row/NumPy +normalization, typed numeric/Unicode snapshots, scalar/ND constructors, scalar +and vector-row append/extend/refresh, fixed-string row outputs, compact-copy, +deletion, materialization, disk/frame round trips, no Python reconstruction, and +malformed-artifact rejection preserving an existing destination. The portable +Python boundary remains **200 cases: 183 passed, 17 opt-in external skips**. +Native default suite **343/343 passed** and complete ASAN/UBSAN suite +**343/343 passed**; the two targeted artifact/interpreter sanitizer tests also +passed separately. Added descriptor initializers produce no new test warnings; +the full sanitizer build exposes older aggregate-initializer warnings in existing +nonportable test files. No sanitizer error was reported. + +Exact remaining gates: independent function-specific/platform accuracy matrix, +Windows/Linux/WASM and stock-published-pin wheel CI, publication/native pin +authorization, and a clean whole-tree docs gate (existing installation list-table +parsing errors, missing tutorial images, duplicate/generated documentation and +unrelated reference warnings remain). Development docs build succeeds and the +portable page has no reported diagnostics. Local draft integration is tested; +do not claim all beta/platform acceptance criteria complete. Final post-edit +Python/lint/docs/wheel results are recorded in the addendum below. + +### Exact implementation file inventory (preserved earlier work included) + +Python tracked changes: +`doc/reference/portable_dsl.rst`, `src/blosc2/b2objects.py`, +`src/blosc2/blosc2_ext.pyx`, `src/blosc2/core.py`, `src/blosc2/ctable.py`, +`src/blosc2/deserialization.py`, `src/blosc2/dict_store.py`, +`src/blosc2/dsl_artifact_bridge.h`, `src/blosc2/dsl_kernel.py`, +`src/blosc2/embed_store.py`, `src/blosc2/lazyexpr.py`, +`src/blosc2/msgpack_utils.py`, `src/blosc2/ndarray.py`, +`src/blosc2/portable_kernel.py`, `src/blosc2/schunk.py`, +`src/blosc2/tree_store.py`, `tests/ctable/test_ctable_computed_cols.py`, +`tests/ctable/test_ctable_dsl_columns.py`, `tests/ndarray/test_dsl_kernels.py`, +`tests/ndarray/test_lazyudf.py`, `tests/test_b2objects.py`, +`tests/test_deserialization.py`, `tests/test_dsl_portable.py`, +`tests/test_objectarray.py`. +New implementation files: +`src/blosc2/portable_lazy.py`, `tests/test_portable_descriptor.py`, +`tests/test_portable_descriptor_host.py`, `tests/test_portable_lazy.py`, +`tests/test_portable_policy.py`, `tests/test_portable_table_export.py`. +Durable task files: this progress document, the approved implementation plan and +scope inventory. Generated extension/build/wheel/log products are not source +implementation files; unrelated user untracked files remain untouched. + +Miniexpr tracked changes: +`CMakeLists.txt`, `src/miniexpr.h`, `src/dsl_portable.c`, +`src/dsl_artifact.c`, `src/dsl_compare.c`, +`src/dsl_compile.c`, `src/dsl_compile_internal.h`, +`src/dsl_compile_support.c`, `src/dsl_eval.c`, `src/dsl_eval_internal.h`, +`src/dsl_jit_runtime_host.c`, `src/dsl_jit_runtime_internal.h`, +`src/dsl_jit_runtime_nonhost.c`, `src/dsl_parser.c`, `src/dsl_parser.h`, +`src/functions.c`, `src/functions.h`, `src/miniexpr.c`, +`src/miniexpr_artifact.h`, `src/miniexpr_internal.h`, +`tests/test_dsl_artifact.c`, `tests/test_dsl_portable_validation.c`. +New miniexpr implementation files: +`doc/dsl-spec/1.0.md`, `doc/dsl-spec/artifact-1.0.md`, +`doc/dsl-spec/features-1.0.json`, `src/dsl_portable_expr.c`, +`src/dsl_portable_expr.h`, `src/dsl_portable_fp.h`, +`src/dsl_portable_types.c`, `src/dsl_portable_types.h`, +`src/dsl_semantic_profile.h`, `tests/test_dsl_portable_checked.c`, +`tests/test_dsl_portable_interp.c`, `tests/test_dsl_portable_types.c`. + +### Authored-save scope correction — latest verification (authoritative) + +This section supersedes all verification records below. No native implementation +changes were needed for authored-save conversion; the existing native 1.0 parser, +compiler and artifact validation remain authoritative. All checks used conda +`blosc2` and explicit development overrides where building wheels. + +- Full Python default suite: **11280 passed, 55 skipped**, 32.62s. Restored native + roundtrips for add-square, static loops/where, slices, named bindings, DictStore + operands, ObjectArray, captures/scalar constants, frames and nested arithmetic. + Complete logical-block reductions plus ND coordinates and sliced reads are + checked against independent expected values, retaining original partitions. +- Seven portable modules: **183 passed, 17 external skips = 200 cases**; tests + extend existing orthogonal cases rather than introducing another parameter grid. + Unsupported print/callback stores preserve old entries on Embed/Dict/Tree routes; + unsupported disk saves and loaded legacy recipe saves preserve destinations. +- Complete native suite: **343 passed**, 8.34s. Complete ASAN/UBSAN suite: + **343 passed**, 8.49s, `ASAN_OPTIONS=symbolize=0`. No sanitizer failures. +- Development-override wheel built and installed only to an isolated target; + isolated subprocess asserted package path and removed only its editable finder. + Portable modules plus b2objects/ObjectArray/ndarray DSL/CTable DSL/computed-column + modules: **458 passed, 17 external skips, 1 network deselected**, 4.22s. + Wheel `blosc2-4.14.2.dev0-cp311-abi3-macosx_26_0_arm64.whl`, SHA256 + `a4255253709584e7a1ccb69d585dc9ed6cc8a80d100b59a7bed0f6234f31e1c9`. + This is not stock-pin/platform certification. Editable import path and descriptor + availability were subsequently rechecked and preserved. +- Ruff check/format passed for the 10 Python files touched by this correction; + repository whitespace check passed. Sphinx build succeeds with **391 whole-tree + warnings**, including missing generated API stubs; the portable page itself has + no reported diagnostic. The clean whole-tree docs gate remains incomplete. +- Authoring route: `portable_from_lazyudf` in `src/blosc2/portable_lazy.py`, shared + through `b2objects.encode_b2object_payload` and LazyUDF save/frame. CTable APIs + accept DSLKernel plus `dtype`, explicit `row_domain='independent'` and optional + `cardinality='block_scalar'`; the approved plan and portable docs record this. + No legacy source fallback/migration or changed elementwise-to-scalar shape. +- Logs under the approved temporary root: `author-save-python.log`, + `author-save-portable.log`, `author-save-native.log`, `author-save-sanitized.log`, + `author-save-wheel-build.log`, `author-save-wheel-tests.log`, `author-save-docs.log`. + Wheel and isolated target directories: `author-save-wheel`, `author-save-wheel-smoke`. +- Local corrected scope is fulfilled. External function-specific accuracy, + Windows/Linux/WASM, authorized publication/pin and stock-wheel certification, + and clean whole-tree docs remain pending. No commits/push/publication occurred. + +### Public validator and finite-reference closure — earlier verification (superseded) + +These results supersede the earlier verification records below. All Python, +build and test commands used conda `blosc2`; native overrides were explicit. + +- Rebuilt the installed editable extension with the documented local miniexpr + and C-Blosc2 overrides. Rechecked `blosc2.__file__` resolves to this repository's + `src/blosc2/`, descriptor support is available, and 1.0 Unicode source validation + succeeds after both isolated wheel installations. Published pin unchanged. +- Full default Python suite: **11280 passed, 55 skipped**, 42.87s. +- Final complete native CTest: **343 passed**, 8.73s. Final complete ASAN/UBSAN + CTest: **343 passed**, 8.86s, `ASAN_OPTIONS=symbolize=0`. These include the + extended validator and independent analytic/exact reference fixtures, including + the final floating-power NaN exceptions. No sanitizer errors or new warnings + in the modified validator/interpreter tests were reported. +- Isolated development-override wheel: **183 passed, 17 external skips** across + the seven portable modules = **200 cases**. No new parametrized cases or local + 1.0 skips; validation assertions extend the existing authoring test. Wheel: + `blosc2-4.14.2.dev0-cp311-abi3-macosx_26_0_arm64.whl`, SHA256 + `39dc5fcd00867991a06dc14426829a305bccc3fa581224e5bb8dfc71b0e096bf`. + Isolated subprocess removed only its own editable finder, asserted wheel import + path, and ran pytest with `-n 0`. This is **not stock-pin certification**. +- Separately built/installed isolated artifact-disabled wheel: core frozen 0.1 + and draft 1.0 numeric/string/ND source validation passed, missing ND context + rejected, ordinary arithmetic passed, optional artifact import explicitly + rejected. Plain source validation does not require the optional JSON loader. +- Ruff check and format pass for all **27 changed/new Python files**; both + repositories' `git diff --check` pass. Finite feature JSON parses successfully. +- Sphinx HTML build succeeds with **142 whole-tree warnings**; no diagnostic + against `doc/reference/portable_dsl.rst` or the updated validator docstring. + Existing generated/reference/installation/image diagnostics are not a clean + documentation gate and remain recorded as outstanding. +- Logs under `/private/var/folders/tb/7hwq2y354bb_68xwxjwjwwlr0000gn/T/opencode/`: + `closure-editable-build.log`, `closure-python.log`, `closure-native-build.log`, + `closure-native-ctest.log`, `closure-sanitized-build.log`, + `closure-sanitized-ctest.log`, `closure-wheel-build.log`, + `closure-wheel-tests.log`, `closure-disabled-build.log`, `closure-docs.log`. + Isolated wheel directories are `closure-wheel`, `closure-wheel-smoke`, + `closure-disabled-wheel`, and `closure-disabled-smoke`. +- Local requested implementation closure is complete. Remaining release gates: + independent function-specific/platform accuracy acceptance, Windows/Linux/WASM + execution, authorized native publication/pin and stock-pin wheel matrix, and + clean whole-tree docs. No beta-ready claim, publication, dependency change or + destructive repository operation was performed. + +### Earlier local verification addendum (superseded by closure results above) + +- `conda run -n blosc2 pytest -q`: **11280 passed, 55 skipped**, 38.69s, + after final row-shape/broadcast/width fixes. Subsequent test-helper/comment + cleanup reran ndarray DSL and CTable DSL tests: **138 passed**, 1.88s. +- Seven compact portable test modules: **183 passed, 17 skipped** = **200**; + the 17 skips are 16 external frozen-0.1 corpus cases and one external artifact + runner. No local draft 1.0 test skips. Frozen 0.1 self-contained artifact tests + continue to execute, with default export still 0.1. +- Complete native interpreter CTest: **343 passed**. Complete ASAN/UBSAN CTest: + **343 passed**, 43.90s, `ASAN_OPTIONS=symbolize=0`. Targeted artifact and + portable interpreter sanitizer pair: **2 passed**, 0.87s. No test failure or + sanitizer error; the existing nonportable aggregate initializer warnings noted + above do not indicate a new implementation warning. +- Ruff lint and format: all **27 changed/new Python files passed**. Cython is + validated by actual wheel compilation, not Ruff's Python parser. Both repos' + `git diff --check` passed. +- Final native-development override wheel: + `blosc2-4.14.2.dev0-cp311-abi3-macosx_26_0_arm64.whl`, SHA256 + `1d88d169e4a2af3df0747bdd5002deca019fab77aeac9b32aa3d40a1bb0f05a9`. + Built with explicit local miniexpr/C-Blosc2 source overrides and artifacts ON. + Installed into a separate temporary target; removed the editable import finder + only inside the smoke subprocess and asserted the loaded wheel package path. + The **entire 200-case portable suite** ran against that isolated wheel: + **183 passed, 17 external opt-in skipped**, 1.08s, including typed authoring, + table vector/string/constructor persistence and lazy descriptor tests. + This is **not** a published-pin/stock-wheel platform certification result. +- Separate artifact-disabled development wheel built and isolated smoke passed: + ordinary array arithmetic works, availability query is false, portable loader + explicitly raises `NotImplementedError`. Editable development install remained + untouched and was rechecked for the active descriptor ABI afterwards. +- Final incremental Sphinx HTML build succeeded with **117 whole-tree warnings**; + no diagnostic names `doc/reference/portable_dsl.rst` after correcting its new + heading underline. Earlier clean full build exposed existing installation + list-table parsing errors and unrelated missing-image/reference warnings. + A successful non-`-W` build is not a clean whole-tree documentation gate. + +Logs/builds/wheels remain under the approved temporary root +`/private/var/folders/tb/7hwq2y354bb_68xwxjwjwwlr0000gn/T/opencode/`: +`portable-1-full-python-final.log`, `portable-1-comments-regression.log`, +`portable-1-native-ctest.log`, `portable-1-sanitized-all-ctest.log`, +`portable-1-sanitized-all-build.log`, `portable-1-docs-final.log`, +`portable-1-final-wheel/`, `portable-1-final-wheel-smoke/`, +`portable-1-disabled-wheel/`, `portable-1-disabled-smoke/`. +The supported local draft integration is implemented and tested. External +platform/independent-accuracy/stock-pin gates remain unexecuted, and no dependency +pin, publishing or repository state-changing git action was performed. + +### Independent correctness review addendum (2026-10-07) + +Scope: independently read repository instructions, approved scope/plan and current +handoff; inspected profile-aware expression typing/conversions, reduction masks, +scalar returns, constant decoding, artifact width/capability/cardinality and +descriptor checks, Python typed capture/export, lazy original-group reads and +persistence/policy propagation. This is focused local review, **not complete +assurance**, a whole-JIT audit or external platform certification. + +Concrete fixes: + +- `../miniexpr/src/dsl_eval.c`: portable `for` evaluation no longer zeroes the + iterator local in inactive lanes while another lane continues. Before the fix, + `for i in range(x): ...; return i` on `[2, 4]` returned `[0, 3]`, rather than + `[1, 3]`. Preserve full-DSL behavior outside the versioned portable profile. + Native regressions cover exhausted ranges, lane-specific break, and runtime + rejection of undefined iterators for empty ranges. +- `src/blosc2/portable_kernel.py`: determine integral capture magnitude with a + Python integer rather than `abs()` in the NumPy fixed-width dtype. Capturing + `np.int64(INT64_MIN)` as float64 formerly raised an overflow RuntimeWarning + (an exception under the suite's warning policy). Captured conversion and + immutable snapshot now have an authoring regression. +- Merged host boundary checks into existing portable cases: masked scalar return + through a reduction local with the first lane invalid, all-invalid sum identity, + tampered scalar cardinality/string output width rejection, and reverse/empty + elementwise partial reads of `x + sum(x)` preserving exactly the original group. + No test counts expanded, tests suppressed or failures relabeled. + +Findings from the initial review — resolved by the contract follow-up below: + +1. **Divergent block-scalar returns:** native import accepts + `s = sum(x); if x < 0: return s + 1; return s` as `block_scalar` (normalized + multiline DSL). Input `[-1, 2]` returns `1`: the first subset wrote `2`, then + the remaining subset overwrote the one scalar output with `1`. + `dsl_compile.c` recognizes the reduced local as uniform without accounting for + varying return control; `dsl_eval.c` writes each scalar return to the same slot. + The follow-up now rejects divergent scalar returns structurally; it neither + invents a selection rule nor reinterprets cardinality. +2. **Implicit legacy permission at the low-level MessagePack boundary:** + `msgpack_unpackb(payload)` in `msgpack_utils.py` deliberately defaults to FULL. + A handcrafted extension-43 legacy `lazyudf` record reconstructed a `LazyUDF` + without passing `deserialize='full'`. Safe-mode paths retain propagation and + rejection; this is not a demonstrated safe-mode bypass. The helper's documented + compatibility exception conflicted with the plan's explicit-opt-in wording. + The follow-up now defaults this boundary to safe and propagates explicit-full + permission through nested values, without a legacy/default-full fallback. + +Exact post-fix verification (conda `blosc2`, local native development override): + +- Rebuilt native interpreter, sanitizer build and Python editable extension using + the existing local miniexpr/C-Blosc2 FetchContent overrides; published pin unchanged. +- Full Python `pytest -q`: **11280 passed, 55 skipped**, **31.17s**, after final + boundary-test edits. Seven portable modules: **183 passed, 17 external skipped**, + **1.79s**, still exactly **200 cases**. +- Full native CTest: **343/343 passed**, **8.75s**. Full sanitizer CTest with + `ASAN_OPTIONS=symbolize=0`: **343/343 passed**, **8.91s**. No sanitizer error; + incremental review builds reported no warnings. A new exploratory test initially + assumed preassigned loop iterators were admissible; native compilation rejects + this existing syntax restriction. Replaced that assumption with the actual + supported empty-range/undefined-local boundary, not a change in language policy. +- Ruff lint and format checks pass for all four Python files changed by review; + both repos' `git diff --check` passes. No post-review wheel/docs rebuild claimed. +- Logs: approved temporary root, `portable-1-review-{native-build,native-ctest, + sanitized-build,sanitized-ctest,editable,full-python,portable-python}.log`. + +External beta gates remain independent function/platform accuracy certification, +Linux/Windows/WASM and stock-published-pin wheel CI, publication/pin authorization, +and clean whole-tree docs. The semantic/policy findings above were additional +local acceptance concerns and have now been resolved, as recorded below. +No commits, pushes, pin changes or publishing performed; unrelated files preserved. + +### Contract follow-up — both independent-review concerns resolved (2026-10-07) + +- `../miniexpr/src/dsl_compile.c` validates block-scalar return coherence after + static type/provenance joins converge. Reject returns under typed lane-varying + branches or loop bounds/conditions, including scalar returns in loops whose + lane-varying break/continue can split the return mask. Diagnostic: + `ambiguous block-scalar output: return under lane-varying control or loop flow`. + No first/last scalar selection and no output-cardinality reinterpretation. + Uniform reduced-scalar conditions/coherent scalar loops still compile; varying + loops may rejoin before a single top-level scalar return. Nested loop flow + rejoins locally rather than tainting unrelated outer returns. +- This intentionally conservative check also rejects matching scalar return + expressions inside a varying branch/loop: equality alone does not establish + coherent group control flow. The exact excluded patterns are documented in + `../miniexpr/doc/dsl-spec/1.0.md` and `doc/reference/portable_dsl.rst`. + Native and merged Python cases exercise divergent reduced-local returns, + varying range/while/elif, lane-varying break/continue, and accepted reduction- + controlled/coherent-loop and post-rejoin scalar returns. +- `src/blosc2/msgpack_utils.py`: public and private decoding boundaries default + safe. Explicit-full extension decoding passes its effective policy recursively + into frames, structured references, NumPy object values and sets. Audited all + source callsites: SChunk VLMeta/getall, EmbedStore metadata, ObjectArray and + BatchArray already pass their owning carrier's policy; proxy reads explicitly + pass safe. No internal call inherits the newly changed public default as a + substitute for caller policy. Locally constructed/full containers retain + their existing effective policy; safe-opened containers remain safe. +- Merged legacy MessagePack checks into the existing portable policy case: + default/safe handcrafted extension-43 legacy payloads, both direct and nested + in extension-46 object arrays, reject with a monkeypatched source-reconstruction + failure hook never called. Explicit-full decoding reconstructs those same + values intentionally. Existing local/full metadata and container tests pass + without adding default-full fallback or weakening any safe assertion. + +Final exact local verification: + +- `conda run -n blosc2 pytest -q`: **11280 passed, 55 skipped**, **34.60s**, after + final boundary checks. Seven portable modules: **183 passed, 17 external + skipped**, **3.10s**, exactly **200 cases**. Targeted descriptor/policy pair: + **10 passed**, **2.15s**. +- Rebuilt interpreter and sanitizer native builds. Complete CTest: + **343/343 passed**, **45.29s**; complete ASAN/UBSAN CTest with + `ASAN_OPTIONS=symbolize=0`: **343/343 passed**, **45.59s**. No sanitizer error or + new compiler warning; both incremental links reported the existing duplicate + `-lm`/`libminiexpr.a` warning. +- Rebuilt editable install with explicit local miniexpr/C-Blosc2 overrides; + rechecked installed source import and descriptor ABI after isolated wheel work. +- Built native-override wheel + `blosc2-4.14.2.dev0-cp311-abi3-macosx_26_0_arm64.whl`, SHA256 + `a0874703e46863b67040fbc096aa007c734e56f5f1b26da1fb903caa670cf649`. + Installed to a separate temporary target; removed the editable finder only in + the smoke subprocess and asserted the package path. Complete portable suite + against the isolated wheel: **183 passed, 17 external skipped**, **1.52s**, + using `-n 0` so worker startup cannot reintroduce editable imports. This is + local-development override evidence, **not stock-published-pin certification**. +- Ruff lint/format pass for all six Python implementation/test files changed by + independent review/follow-up; both repos' `git diff --check` passes. +- Sphinx command exits successfully; portable page has no diagnostic. Whole-tree + output includes **818 WARNING / 4 ERROR diagnostic lines**, including existing + installation list-table errors and unrelated reference/image issues. This is + not a clean docs gate, and no unrelated docs cleanup was attempted. +- Approved temporary-root logs use `portable-1-contract-` prefix: native/sanitized + build and CTest, editable, full/portable Python, wheel build/install/test and + docs. Wheel and target directories: `portable-1-contract-wheel/` and + `portable-1-contract-wheel-smoke/`. + +No remaining local semantic question from these two findings. External beta +gates remain independent function/platform accuracy certification, Linux/Windows/ +WASM and stock-published-pin wheel CI, authorized publication/native pin change, +and clean whole-tree docs. No backend expansion, commits, pushes or publication. + +## HISTORICAL RECORDS — superseded status/next-actions, retained verification history + +All inventory, pending-work and skip statements below describe earlier sessions. +They are not current handoff instructions. Use CURRENT STATUS above and its final +verification addendum for resume decisions. + +## Target and approved decisions + +Implement `portable-DSL-1.0-implemenation.md` through beta readiness. All Q1–Q3 +are approved: standard signed/unsigned integer widths and operand promotion; +explicit block-scalar cardinality/grid output; explicit `deserialize="full"` +legacy opt-in, without migration tooling. Interpreter correctness comes first. +No final contract freeze or publication is implied by completing implementation. + +## Starting state + +- Python-Blosc2: `23a2a91a`; no tracked modifications on entry. +- Miniexpr: `98b2bf9`; no tracked modifications on entry. +- Numerous unrelated untracked files exist in Python-Blosc2; preserve them. +- Native repository instructions: `../miniexpr/AGENTS.md` (K&R C style, minimal + changes, relevant tests, no new dependencies). +- Python commands must run through `conda run -n blosc2`. + +## Verification log + +- Baseline: `conda run -n blosc2 pytest tests/test_portable_artifact.py + tests/test_dsl_portable.py -q`: **159 passed, 41 skipped**. Skips include opt-in + external corpus/runner tests; this does not certify portable 1.0. +- Native build directory: + `/private/var/folders/tb/7hwq2y354bb_68xwxjwjwwlr0000gn/T/opencode/miniexpr-portable-1-interpreter`. + Configured with `conda run -n blosc2 cmake -S /Users/faltet/blosc/miniexpr -B + -DMINIEXPR_ENABLE_TCC_JIT=OFF -DMINIEXPR_USE_SLEEF=OFF + -DMINIEXPR_USE_ACCELERATE=OFF -DMINIEXPR_BUILD_SHARED=OFF + -DMINIEXPR_BUILD_EXAMPLES=OFF -DMINIEXPR_BUILD_BENCH=OFF + -DMINIEXPR_BUILD_ARTIFACT=ON`; built with `--parallel 8`. +- First native suite with promotion helper: **341/341 passed**. Latest suite + adds checked-arithmetic tests: `conda run -n blosc2 ctest --test-dir + --parallel 8 --quiet --output-log /portable-1-native-ctest.log` + exited successfully. Current suite has 342 tests. +- Checked arithmetic compiled independently with `conda run -n blosc2 cc + -std=c99 -Wall -Wextra -Werror -fsanitize=address,undefined + -fno-sanitize-recover=all -I /Users/faltet/blosc/miniexpr/src + /Users/faltet/blosc/miniexpr/src/dsl_portable_types.c + /Users/faltet/blosc/miniexpr/tests/test_dsl_portable_checked.c + -o /portable-1-checked-sanitized`; executing it **passed**. + No compiler/sanitizer warnings. Full CMake build emits its existing duplicate + static-library/`-lm` linker warning; no new compiler warning was observed. +- Draft matrix audit: all **87** distinct registered `functions.c` builtin names + are covered, plus four DSL intrinsics (`int`, `float`, `bool`, `range`); no + duplicate matrix names. This is coverage of the inventory, not certification. +- `git diff --check` passes in both repositories. + +## Milestones + +1. In progress: implemented draft schema and finite builtin inventory; concrete + platform/domain/tolerance certification remains (not a schema design blocker). +2. Integrated: profile-aware typed interpreter and draft artifact 1.0 acceptance + for validated implemented capabilities; standalone 0.1 validator stays frozen. +3. Integrated: numeric operations/casts/comparisons/lazy operands and static local + joins. Remaining work is the finite conformance/platform matrix. +4. Integrated: ordered masked reductions, padded lanes, scalar cardinality, + empty standalone blocks and evaluation-local caches/definition masks; expand + returned-lane/control-flow/concurrency certification fixtures. +5. Integrated: extended artifact descriptor ABI, typed signatures/constants and + immutable width/cardinality/capability/context validation. +6. Integrated: fixed strings, dynamic integral indices/bounded replacement, and + logical ND coordinates; platform/endian/Unicode conformance remains. +7. In progress: conditional Python bridge and standalone descriptor routing done; + logical lazy scheduling, partial reads and compiled Python 1.0 tests remain. +8. Pending: all persistence routes and legacy policy enforcement. +9. Integrated: interpreter-only optional-JIT fallback and explicit required-JIT + unsupported diagnostic; frozen/full profiles preserve their original behavior. +10. Pending: complete conformance/platform/wheel/docs verification. + +## Findings to retain + +- `functions.c` registers `log` differently depending on `ME_NAT_LOG`; the + portable profile must bind natural log explicitly, independent of build flags. +- Existing artifact eval assumes elementwise `nitems` output and skips empty + calls. Extended descriptors are required for block-scalar and empty identities. +- Existing `b2objects.py` internally hard-codes `deserialize="full"` on operand + opens. Effective user policy must propagate instead. +- Full-DSL compilation uses shared expression helpers; approved operand typing + must be profile-aware, not an unversioned global change. + +## Next action + +Continue with static local joins, remaining numeric functions and mask conformance, +then extended artifact descriptors/cardinality/context. +Do not enable 1.0 acceptance until the typed-tree/evaluator actually enforces the +contract. Current public runtime APIs still accept only 0.1; staged semantics are +isolated from frozen/full-DSL execution. No semantic blocker identified yet. + +## Continuation increment: typed interpreter integration + +- Added internal `dsl_compile_program_profile()` and `private_compile_profile_ex()`; + the original entry points retain full-DSL behavior. Profile metadata is per + program/parser state, not global. The 1.0 raw-tree path bypasses full-DSL numeric + promotion, optimization, bytecode and output-context node retyping. +- Parser leaves preserve exact decimal integer magnitudes (through uint64), weak + literal identity and direct float32 literal rounding. Unary literal signs are + resolved without executing arithmetic. Typed pass inserts checked conversion + nodes, including final output conversion only after operand-driven computation. +- Added `dsl_portable_expr.[ch]` operating on the existing `me_expr` tree and + checked helpers. Core arithmetic, shifts/bitwise, powers, exact mixed integer + comparisons, int/float/bool casts and lazy truth/where now execute natively. + Unsupported operations still reject in this **internal staged** path. +- DSL assignment/return and condition masks route through the checked evaluator; + skipped lanes do not execute invalid arithmetic. New locals infer independently + of output dtype. Existing locals still use their first inferred type; approved + static join inference remains to implement. +- Optional JIT requests are forced to interpreter before IR construction in 1.0. + Print is rejected. No public 1.0 dispatch or persistence changed yet. +- Reconfigured/rebuilt the native build above; `tests/test_dsl_portable_interp` + passed. `conda run -n blosc2 ctest --test-dir --parallel 8 --quiet + --output-log /portable-1-native-ctest.log` passed (343 tests). +- Additional changed native files: `functions.[ch]`, `miniexpr.c`, + `dsl_compile.c`, `dsl_compile_internal.h`, `dsl_jit_runtime_internal.h`, + `dsl_eval.c`, `dsl_semantic_profile.h`, `dsl_portable_expr.[ch]`, + `tests/test_dsl_portable_interp.c`, and the CMake source list. +- This initial increment's tests were subsequently expanded and explicitly made + assertion-enabled even in Release builds; use the latest verification below. + +## Continuation increment: ordered masked reductions and numeric coverage + +- Profile-aware DSL parsing retains `//=` instead of lowering through floating + `floor(a / b)`. Expression tokenization and comparison lowering recognize `//`; + full-DSL tokenization/compound-assignment behavior stays unchanged. Checked + integer floor division/remainder, float floor division/divisor-sign remainder, + and distinct truncation-sign builtin `fmod` now execute through typed nodes. +- Added explicit builtin identity dispatch for the staged unary libm family, + aliases, selected binary libm functions, abs/square/sign and real-only + conj/real/imag. Calls use float32 libm entry points for float32 computation and + float64 otherwise; no external callback is executed. Natural-log binding is + independent of `ME_NAT_LOG`. `rint` ties-to-even does not use host rounding mode; + `round` keeps native half-away ties. Scalar fmin/fmax zero ties are explicit. +- sum/prod/mean/min/max/any/all typed nodes now reduce current participating lanes + in logical order, with checked integer accumulation and float32 operation + boundaries. Empty identities/errors, numeric NaN propagation and min/max zero + ties are implemented. A per-expression evaluation-local reduction cache + broadcasts without quadratic repeated reduction work for normal expressions; + it is never stored on a compiled/shared handle. +- Expanded native integration coverage: exact int64/uint64 literals and + comparisons, contextual literal errors, arithmetic/shift/power extrema, + operand-vs-output widths, narrowing, NaN truth/comparisons, libm typing, + conditional invalid arithmetic, nested masked reductions, loop early exit, + returned lanes, continue, empty identities and ordered cancellation/overflow. +- Added profile guards to `dsl_jit_runtime_host.c`, + `dsl_jit_runtime_nonhost.c`, and both execution paths in `dsl_eval.c` so no + uncertified cached/backend function can execute for a 1.0 program. +- Staged compilation rejects external callbacks, print, non-strict FP, ND symbols + without the unfinished explicit descriptor, unsupported calls/strings, nested + reductions and reduction-valued short-circuit/where alternatives needing + additional expression masks. These are **temporary implementation diagnostics**, + not approved scope removals. Local dtype-changing reassignment rejects clearly + rather than silently narrowing to the first assignment. Static joins remain + required. Inconsistent return cardinality now rejects. +- Additional changed native files: `dsl_parser.[ch]`, `dsl_compare.c`, + `dsl_jit_runtime_host.c`, `dsl_jit_runtime_nonhost.c`, and updated draft `1.0.md`. + +### Latest reproducible verification + +Let `T=/private/var/folders/tb/7hwq2y354bb_68xwxjwjwwlr0000gn/T/opencode`. +All commands ran through the required `blosc2` environment. + +- `conda run -n blosc2 cmake --build $T/miniexpr-portable-1-interpreter --parallel 8` + passed; log `$T/portable-1-build.log`. Normal build has only the previously + observed duplicate-library linker warning. +- `conda run -n blosc2 ctest --test-dir $T/miniexpr-portable-1-interpreter + --parallel 8 --quiet --output-log $T/portable-1-native-ctest.log`: **343 passed**. +- Integrated sanitizer build configured with: + `conda run -n blosc2 cmake -S /Users/faltet/blosc/miniexpr + -B $T/miniexpr-portable-1-sanitized -DMINIEXPR_ENABLE_TCC_JIT=OFF + -DMINIEXPR_USE_SLEEF=OFF -DMINIEXPR_USE_ACCELERATE=OFF + -DMINIEXPR_BUILD_SHARED=OFF -DMINIEXPR_BUILD_EXAMPLES=OFF + -DMINIEXPR_BUILD_BENCH=OFF -DMINIEXPR_BUILD_ARTIFACT=ON + -DCMAKE_BUILD_TYPE=Debug + '-DCMAKE_C_FLAGS=-fsanitize=address,undefined -fno-sanitize-recover=all -Wall -Wextra'`. + `conda run -n blosc2 cmake --build $T/miniexpr-portable-1-sanitized + --target test_dsl_portable_interp --parallel 8` and + `conda run -n blosc2 $T/miniexpr-portable-1-sanitized/tests/test_dsl_portable_interp` + **passed**, with no sanitizer findings. The warning-enabled shared-source build + emits numerous existing unused-function/initializer warnings; no warnings came + from the new expression module. Log `$T/portable-1-sanitized-build.log`. +- Independently: `conda run -n blosc2 cc -std=c99 -Wall -Wextra -Werror -I src + -c src/dsl_portable_expr.c -o $T/portable-1-expr-warning-check.o` **passed**. +- Python regression command from the baseline rerun: **159 passed, 41 skipped**. + It uses the installed/pinned native dependency, not sibling-checkout inference; + it does not verify staged 1.0 or newly edited native code. +- Latest `git diff --check` passes in both repositories. + +### Handoff and true remaining gates + +No unresolved approved-semantic conflict or external blocker was encountered. +The implementation is coherent/tested but **not beta-ready**. No public 1.0 +validator/artifact acceptance, Python native bridge/persistence transition or pin +update was made; no release/publication/platform-CI result is claimed. + +Next concrete work: + +1. Add static numeric local joins (do not reintroduce output-context typing), + finish remaining matrix operations (`fma`, `ldexp`, `logaddexp`, e/pi and + combinatorics), per-function domains/tolerances and bound/range conversion + conformance. Review the FP environment/nearest-rounding requirement explicitly. +2. Extend expression masks for reduction-valued lazy operands if admitted; + complete Mandelbrot/partition/padding/concurrent-handle fixtures and cardinality + joins. Existing program eval still broadcasts scalar outputs into nitems slots + and does not execute an empty standalone block; do not certify that old ABI. +3. Implement extended native artifact schema/API with capacities, valid lanes, + logical context and block-scalar outputs. Only then admit strings/ND and public + 1.0 validation/loading, retaining frozen 0.1 dispatch. +4. Continue Python bridge, immutable logical block scheduling, all persistence + routes and effective explicit legacy opt-in, then the remaining beta gates. + Do not update the published native pin to unpublished local code. + +## Further continuation: static joins and strict FP environment + +- Implemented bounded fixed-point numeric local inference using discovery trees + that are discarded, followed by rebuilding against stable slot dtypes. Numeric + return paths also join when output dtype is inferred. Storage conversion is + inserted after RHS operand-driven computation, not before it. Frozen/full DSL + continues its original single-pass compilation. For-variable collision checks + are preserved while permitting discovery-pass rebuilds. +- Added `dsl_portable_fp.h`: staged compilation and expression evaluation save + the caller thread's floating environment, establish nontrapping IEEE nearest/ + ties-even, then restore rounding and exception flags on success/failure. No + shared handle or global semantic switch stores this state. +- Added local reassignment/loop/return-join tests and compilation/evaluation under + FE_UPWARD with pre-existing FE_INVALID, checking nearest arithmetic/literals and + exact caller environment restoration. Target `test_dsl_portable_interp` rebuilt + and **passed** in the ordinary native build. Integrated sanitizers/full suite + will be rerun after the next dependent increment. +- Supersedes the earlier temporary "local type joins not implemented" diagnostic + and nearest-rounding TODO. Remaining operation, masks, descriptor and host gates + are unchanged; public 1.0 acceptance remains closed. + +## Further continuation: remaining numeric operations and lazy reduction masks + +- Added typed fma/fmaf (explicit fusion), integral-exponent ldexp with checked int + bounds, stable logaddexp including equal infinities, exact e/pi constants, and + checked integral fac/ncr/npr. Combinatorics retains the promoted integral dtype; + negative operands or k>n error. Binomial factors cancel before multiplication, + so e.g. uint64 ncr(67,33) succeeds without spurious intermediate overflow. +- Found native pure FUNCTION0 token value 40 collides with logical-not token 40. + Portable tokenization preserves zero-argument builtin identity without that + token flag; frozen/full behavior is not changed. +- Reduction-valued where alternatives and short-circuit RHS now have explicitly + derived participating masks, with evaluation-local child contexts/caches and + ownership cleanup. Discarded arithmetic/reductions are not executed. Generated + synthetic short-circuit assignments are admitted structurally while retaining + the prohibition on user reduction assignments/returns in control-flow bodies. +- Compact integration cases cover checked factorial, exact large binomial, + explicit fused cancellation, ldexp, infinite logaddexp, constants, masked + where/and reductions and nested alternative masks. Ordinary native target + `test_dsl_portable_interp` rebuilt and **passed**; sanitizer/full rerun follows. +- Supersedes the temporary reduction-valued lazy-operand diagnostic. All numeric + builtin names now have staged implementations (complete domain/accuracy corpus + and finite per-operation matrix details are still certification work). + +## Further continuation: descriptors, empty groups, definition state and fixtures + +- Added internal `dsl_eval_program_portable()` with a byte-capacity descriptor, + valid-lane mask, single-item block-scalar output and explicit empty scalar-block + execution. Reduction provenance propagates through locals; lane-dependent + condition/range/loop-flow assignments demote uniformity. Empty reductions use + the real zero-lane group, with a separate dependency slot for scalar locals. + Elementwise zero-item calls still skip execution. Legacy eval ABI is unchanged. +- Added per-call/per-lane local initialization masks to staged numeric evaluation; + participating uninitialized reads error, lazy discarded reads do not. Loop + variable writes define only active lanes. Range arguments now use checked int64 + conversions instead of legacy unchecked float/uint64 casts. +- Added public extended **descriptor ABI** (not language/schema 1.0 loading): + `me_artifact_eval_ex`, buffer widths/capacities, logical-context/mask fields, + cardinality and itemsize queries. Frozen 0.1 rejects unavailable context/masks. + Product/address extent/alignment/overlap checks precede execution; old ABI is + preserved. Tests cover undersized/misaligned/overlapping buffers, bad descriptor + versions, overflow and empty calls with no data/output buffers. +- FP environment setup now also verifies gradual float32/float64 underflow, + rejecting flush-to-zero/denormals-are-zero environments without arch-specific + or global mutable switches. Updated native language/artifact drafts. +- Compact fixtures added for scalar output sentinels, empty sum/mean/min, local + scalar provenance, definition masks, invalid range bounds, lane-dependent + cardinality, Mandelbrot-style break/partition/padding, and concurrent shared + handle calls with distinct caller rounding/exception flags. +- Descriptor/artifact and initial empty-group increment passed all **343** native + tests; targeted interpreter/artifact ASAN/UBSAN tests both passed. Subsequent + definition/range/FP/fixture/cardinality edits are being verified in the next + full/sanitizer rerun. No public 1.0 acceptance or native pin update occurred. + +- Latest integrated rerun after definition/range/gradual-underflow fixtures and + lane-dependent cardinality demotion: full **343/343 native tests passed**; + targeted artifact/interpreter ASAN/UBSAN **2/2 passed**; the typed expression + module still compiles with `-Wall -Wextra -Werror`; Python baseline rerun is + **159 passed, 41 skipped**; both repository `git diff --check` calls passed. + Ordinary native build retains only the observed duplicate-library linker + warning. Follow-up concurrent error-path FP restoration assertions and the + sinpi/cospi increment below are also covered by the final integrated rerun. + +## Further continuation: pi-scaled math accuracy + +- Replaced staged sinpi/cospi's large `pi*x` intermediate with exact modulo-two + reduction and reflection in pi units before libm evaluation. Integer and + half-integer anchors are exact, including large float32/float64 inputs; near + half-integer cospi avoids cancellation. Documented signed-zero anchors and + non-finite NaN behavior; frozen/full DSL is untouched. +- Added integer/half-integer/large/negative-zero/near-half/infinite input fixtures + for both float precisions. Concurrent shared-handle fixtures now also assert + FP environment restoration after checked-arithmetic failure. +- Final verification: **343/343 native tests passed**, targeted ASAN/UBSAN + interpreter/artifact **2/2 passed**, typed expression source warning check + **passed** with `-Wall -Wextra -Werror`. Python regression remains the latest + **159 passed / 41 skipped** run above. No genuine blocker occurred; beta gates + remain implementation work, not a scope reduction or public 1.0 certification. + +### Precise remaining work after these increments + +1. Finish static cardinality/placement conformance (including returned lanes and + reduction-valued nested flow), per-operation domain/tolerance/type matrix, and + platform-specific strict-FP certification. Extended internal evaluator has not + been certified as a complete artifact execution contract. +2. Connect descriptor-based numeric 1.0 artifact compilation/evaluation only after + validation, typed constants and immutable signature/cardinality are enforced; + finish actual schema 1.0 decoding and required-context/capability queries. +3. Add strings and ND using existing machinery with profile-aware semantics; + verify byte widths, capacities, coordinates and empty logical blocks. +4. Then complete Python bridge/logical scheduling/persistence/legacy policy and + platform/wheel/documentation gates. Keep published pin and public version gates. + +## Continuation: native schema/signatures, strings, ND, and staged Python bridge + +- `me_artifact_load` now dispatches schema/language 1.0 to profile-aware typed + interpreter compilation. Immutable signatures enforce all eleven numeric types, + exact width-checked signed/unsigned constants, IEEE bits, fixed-string widths, + Unicode32BE/byte hex constants, result cardinality and context rank. Unknown, + missing and unimplemented capabilities/operations/signatures explicitly reject. + Source tree scanning requires used numeric/control/reduction/string features. + Draft acceptance is not full certification; 0.1 validator/ABI remain frozen. +- Added internal uniform-input signature marker for strong captured constants; + constants are broadcast in call-local buffers without mutating shared handles. + Descriptor evaluation bypasses legacy tile execution/JIT; legacy eval rejects + 1.0 handles. Added native schema/capability/rank queries. +- Reused existing fixed-string validators, width inference, Unicode 15.0.0 case + tables and kernels through stack-local materialized operand adapters, not a new + parser/engine. Typed nodes handle string values, nested operations, predicates, + concat, lazy where and string-width fixed-point joins. Non-string numeric ops + reject string operands; explicit bool/string truth is defined by first code unit. + Active Unicode input scalars validate; masked padded inputs are not read. +- ND coordinates come only from explicit descriptor shape/origin/extent: checked + row-major logical `_flat_idx`, `_iN`, logical `_nN`, rank. Extent product equals + nitems; out-of-domain padded coordinates require invalid masks. Context buffers + and masks cannot overlap output. There is no implicit physical/global synthesis. +- End-to-end native artifact fixtures cover masked scalar/empty results, exact + uint64 max constants, missing capabilities/cardinality/rank, thirteen byte-string + operations (nested/where), Unicode expansion/truncation/constant endian encoding, + invalid Unicode, and padded 2D coordinates. Target ordinary native tests pass. +- ASAN found an adapter header copy over-read of zero-arity expression allocations; + fixed by copying only `offsetof(me_expr, parameters)` into owned stack headers. + Sanitized artifact executable now passes with `ASAN_OPTIONS=symbolize=0` (the + local symbolizer stalled when reporting the now-fixed finding). Interpreter + sanitizer target also passed. Final full rerun follows below. +- Started conditional Python native bridge: descriptor availability, authoritative + descriptor_info, and explicit evaluate_block (scalar shape(), fixed widths, + masks and logical ND context). Cython generation passed; new optional installed- + native tests never search a sibling checkout. No native pin/build replacement. + +### Exact next task at session limit + +1. Add returned-lane/reduction-local/string concurrent fixtures and finish finite + operation domain/type matrix certification (special domains, float32 result + types, literal/strong operand combinations, endian and width bounds). Dynamic + integral substr/split indices, replace bounds for typed constants/dynamic + strings, and explicit required-JIT rejection were completed subsequently. +2. Complete logical block-grid scheduling and partial reads in the lazy host. + `PortableKernel.from_json`, signature/cardinality/rank metadata, standalone + evaluate and explicit evaluate_block now route to native descriptors when + the installed ABI supports them, without Python reconstruction. Authoring 1.0, + lazy scheduling and persistence remain unchanged. Preserve pin independence; + actual compiled Python/native 1.0 execution tests currently require an opt-in + runtime and skip normally. Low-level Cython generation and bridge header compile + pass; host routing is tested with an explicit test double, not a language engine. +3. Complete all safe persistence routes and explicit legacy policy propagation; + then platform/wheel/docs gates. No genuine blocker or scope conflict occurred. + +- Subsequent native signature increment: integral source/captured/per-lane string + indices materialize into existing kernels with safe bounded clamping; + substring dynamic lengths retain subject width. Replace derives a checked + literal-aware/worst-case bound from capacities, rejecting widths over one MiB + and empty participating needles. Added negative index, UINT64_MAX length, + typed byte constants/replacement and runtime-empty-needle fixtures. Ordinary + and ASAN/UBSAN artifact executables passed. Added explicit `jit-required` + unsupported diagnostic; final integrated rerun follows. + +## Latest integrated verification and resume boundary + +### Current continuation: logical partitions and persistence (local native build) + +- Rebuilt the editable extension in conda `blosc2` using supported CMake + `FETCHCONTENT_SOURCE_DIR_MINIEXPR=/Users/faltet/blosc/miniexpr` and + `FETCHCONTENT_SOURCE_DIR_BLOSC2=.../build-portable-python/_deps/blosc2-src` + development overrides, `pip install -e . --no-build-isolation`. Published + FetchContent pin is unchanged. All three installed-native descriptor tests + now execute and pass; they do not skip in local verification. +- Added `src/blosc2/portable_lazy.py` native-only `PortableLazyArray`, constructed + via `PortableKernel.lazy`. Logical domain/partition tuples are independent of + operand storage grids. Scalar returns allocate the C-order partition grid; + elementwise returns allocate the original domain. Edge groups use actual valid + extents (no padded storage lanes synthesized). ND calls preserve original + logical shape/origin. Native partition lane limits validate at construction. +- Basic slices/integers/ellipsis/negative strides select intersecting original + groups, evaluate each whole group, and only then gather selected output lanes. + Partial scalar reads never repartition a reduction. Fancy indexing conservatively + evaluates the full original result before indexing. `compute`/`rechunk` preserve + partitions while choosing output storage chunks/blocks. Full compute streams + output storage chunks using selected original groups, avoiding full-result + NumPy allocation. Groups crossing output chunk boundaries may be evaluated + repeatedly but are never repartitioned. Partial/fancy reads return NumPy values. + Broadcast operands materialize against each group's extent while preserving + output-domain ND coordinates, with a partial-read regression fixture. +- Portable disk carriers, cframes, MessagePack structured objects, EmbedStore, + DictStore, TreeStore and nested arithmetic LazyExpr payloads roundtrip with + native artifact JSON and logical partitions, no originating function/source + reconstruction. Native artifact load precedes operand binding. Normal tests + never infer a sibling directory; local overrides are development-only. +- Removed new full/Python LazyUDF persistence and the old source fallback. + Shared recursive preflight runs before store overwrite/delete, and LazyUDF + save/frame rejects before touching a destination. Raw legacy UDF carriers + reject on NDArray save/frame too. Existing source-backed files still load only + under explicit effective `deserialize='full'`; policy propagates recursively + through structured operand refs and old LazyArray refs. No migration added. +- Safe arithmetic LazyExpr envelopes now have an AST whitelist (no calls, + attributes, subscriptions or ambient names) before host construction, with + safe policy propagated to every nested operand. Legacy nested DSL cannot hide + behind an arithmetic or portable carrier; explicit full remains required. +- CTable computed/generated legacy DSL metadata is policy-detected before + reconstruction; persistent add/save/frame/copy/physical-pack routes reject + full-DSL source descriptors before output writes. In-memory full DSL computation + remains supported. **Native portable CTable computed/generated transformer + descriptors are still unfinished**; do not claim table integration complete. +- Current new tests cover original-group reads, physical grid mismatch, partial + slices/rechunking, block-scalar grid shapes, ND/Unicode/mixed disk roundtrips, + all five container routes, native-only guard, preserved overwrite destinations, + effective nested legacy policy and CTable policy/preflight. Existing legacy + roundtrip tests now assert the new save rejection, while frozen legacy load + fixtures remain tested with explicit full. Removed 22 redundant external-corpus + Python parameter cases; exhaustive conversion coverage remains native. + +Changed Python inventory added this continuation: `src/blosc2/portable_lazy.py`, +`portable_kernel.py`, `b2objects.py`, `lazyexpr.py`, `schunk.py`, `core.py`, +`ndarray.py`, `msgpack_utils.py`, `embed_store.py`, `dict_store.py`, `tree_store.py`, +`ctable.py`; tests `test_portable_lazy.py`, `test_portable_policy.py`, +`test_b2objects.py`, `test_deserialization.py`, `test_dsl_portable.py`, and +`ctable/test_ctable_computed_cols.py`. Native edits from previous increments +remain preserved; no publishing, pin change or git state operations occurred. +User documentation updated in `doc/reference/portable_dsl.rst` for draft logical +partitions, partial reads, persistence routes and explicit legacy policy. + +Exact next implementation: portable CTable computed/generated descriptors and +row-domain/append/refresh semantics. Full DSL table sources now reject new +persistence but native portable table transformers are not connected yet. Then +finish authoring 1.0 records and the finite native conformance/platform gates. + +Latest verification for this continuation: + +- Combined relevant Python portable/persistence/CTable suite: **315 passed, + 19 skipped**. All actual 1.0 descriptor/lazy/ND/string runtime tests execute, + none skip. The 19 skips are 18 opt-in external 0.1 corpus fixtures and one + opt-in standalone native artifact runner; stock tests still do not discover + sibling sources. Portable-only coverage remains compact after replacing + redundant conversion/corpus parameter cases with orthogonal host boundaries: + **181 passed + 19 skipped = 200 portable Python cases** in the focused run. +- Full native CTest rerun passed (**343 tests**); targeted ASAN/UBSAN artifact and + interpreter rerun **2/2 passed** with symbolization disabled as documented. +- Ruff lint/format for all 18 affected Python source/test files passed; both repo + `git diff --check` calls passed. Local editable build completed successfully; + the three previously skipped installed-native descriptor fixtures passed. +- CTable computed/generated tests now **96 passed**, keeping full DSL local + computation while asserting new source persistence rejection. Frozen legacy + file load remains tested under explicit full. No external platform CI or wheel + matrix executed; do not claim beta readiness. No semantic blocker encountered. + +- Final native build and full CTest run: **343/343 passed**, including all new + schema/signature/string/ND/index/replacement fixtures. Build log retains only + the existing duplicate-library linker warning. +- Final targeted ASAN/UBSAN interpreter/artifact CTest run: **2/2 passed** with + `ASAN_OPTIONS=symbolize=0` to avoid the local symbolizer hang. The real adapter + over-read was fixed before this passing run; it is not being suppressed. +- `dsl_portable_expr.c` and `dsl_artifact.c` independently compiled with + `-Wall -Wextra -Werror`. Cython generation and bridge header syntax checks for + both descriptor-enabled and unavailable branches passed. This is not yet an + end-to-end compiled Python 1.0 runtime certification. +- Python relevant tests: **160 passed, 44 skipped**; three additional skips are + intentional installed-runtime 1.0 descriptor fixtures. The extra passing host + fixture checks native-authoritative metadata, byte-order/stride normalization + and explicit block routing without a source interpreter/test engine. +- Ruff lint/format and both repository diff whitespace checks passed. Source + byte-string literals now contextualize safely in where/output families, with + ASCII checks and bounded UTF32-to-byte materialization; native fixture passes. +- First resumed implementation task: connect `PortableKernel` standalone block + routing to lazy **logical partition scheduling** (immutable C-order block grid, + block-scalar grid result shape, full-group evaluation before partial selection, + explicit ND origin/extent and padding masks), then persistence/legacy policy. + Keep old installed runtime tests independent. In parallel with those dependency + milestones, finish the finite conformance/platform checklist above, not another + numerical approximation polishing loop. No genuine blocker encountered. + +## Files changed in this implementation session (current inventory) + +Python-Blosc2: + +- `plans/portable-DSL-1.0-progress.md`: durable handoff and verification. +- `src/blosc2/dsl_artifact_bridge.h`: version-guarded descriptor ABI/fallbacks. +- `src/blosc2/blosc2_ext.pyx`: low-level signature and block-evaluation bridge. +- `src/blosc2/portable_kernel.py`: authoritative descriptor metadata/standalone + block routing with explicit ND context, no Python source reconstruction. +- `tests/test_portable_descriptor.py`: optional installed-native 1.0 fixtures. +- `tests/test_portable_descriptor_host.py`: pin-independent host routing fixture. +- Previously authored scope/implementation plans and unrelated untracked work + remain preserved. No native pin, public authoring or persistence changes yet. + +Miniexpr: + +- `CMakeLists.txt`: add typed helper/expression sources and native integration tests. +- `src/dsl_semantic_profile.h`: per-program full/portable profile identities. +- `src/dsl_portable_expr.h`, `.c`, `dsl_portable_fp.h`: typed tree validation, + checked interpreter, libm/reductions/masks/string values and local FP policy. +- `src/dsl_compile.c`, `dsl_compile_internal.h`, `dsl_compile_support.c`: + profile compilation, fixed-point local joins/widths/cardinality, ownership. +- `src/dsl_eval.c`, `dsl_eval_internal.h`: masked statement integration, + initialization tracking, scalar/empty/descriptor/ND evaluation. +- `src/dsl_parser.c`, `dsl_parser.h`: profile token/parser integration. +- `src/functions.c`, `functions.h`, `src/miniexpr.c`, `miniexpr_internal.h`: + raw typed expression profile, operator identities, string-kernel adapters. +- `src/dsl_compare.c`: profile-aware integral comparison integration. +- `src/dsl_jit_runtime_internal.h`, `dsl_jit_runtime_host.c`, + `dsl_jit_runtime_nonhost.c`: staged interpreter/JIT guards and program metadata. +- `src/dsl_artifact.c`, `miniexpr_artifact.h`: draft schema/signatures/constants, + capabilities/context/cardinality queries and checked descriptor API. +- `tests/test_dsl_artifact.c`, `test_dsl_portable_interp.c`: end-to-end fixtures. +- `src/dsl_portable_types.h`, `src/dsl_portable_types.c`: internal operand + promotion and division dtypes; checked signed/unsigned integer arithmetic, + floor division/modulo, shifts, nonnegative powers, fixed-width bitwise + operations, float-to-integer and exact integer conversions/comparisons. +- `tests/test_dsl_portable_types.c`: explicit 121-pair expected promotion matrix. +- `tests/test_dsl_portable_checked.c`: exhaustive small-domain and extrema tests. +- `doc/dsl-spec/1.0.md`, `artifact-1.0.md`, `features-1.0.json`: native drafts; + not a claim of implemented 1.0 or a frozen specification. + +Helpers define left shift as checked multiplication, signed right shift as floor +division by a power of two, and nonnegative integer powers (`0**0=1`). Fractional +weak floating literals next to integers/Booleans remain floating rather than +being truncated. These are implementation-led details documented in the draft. diff --git a/plans/portable-DSL-1.0-scope-inventory.md b/plans/portable-DSL-1.0-scope-inventory.md new file mode 100644 index 000000000..4563f230f --- /dev/null +++ b/plans/portable-DSL-1.0-scope-inventory.md @@ -0,0 +1,245 @@ +# Portable DSL 1.0: agreed scope and specification work + +Status: feature-level scope agreed on 2026-10-07. Version 1.0 is the intended +first public compatibility contract; its detailed specification remains draft +until the acceptance gates below pass. Draft 1.0 is the sole public portable +format/default; the unreleased 0.1 path is retired with unsupported-version rejection. + +## Goal + +Persist DSL kernels only when their normalized source, typed bindings, and +execution requirements have a language-independent contract. Validate on save +and independently on load. Preserve convenient authoring syntax when it can be +lowered without retaining Python execution or live Python state. + +Interpreter-first: missing JIT support is not grounds for excluding a feature. +Select fallback before execution. A valid artifact can require capabilities +which a particular host lacks; that host must reject it explicitly. + +## Agreed inclusions + +- Real/integer/Boolean arithmetic, mixed numeric inputs, casts, predicates, + and an explicitly enumerated math-function set, including elementwise `where`. +- Existing branches, loops, local assignments, and loop control. +- ND index/shape symbols with explicit host-supplied logical context. +- Fixed-width Unicode strings/bytes and statically bounded string returns. +- Supported authoring rewrites and immutable typed scalar captures; static + column references become explicit named bindings. +- Limited block-local reductions: top-level reductions and supported + control-flow conditions, including Mandelbrot-style `all(...)` early exit. +- Portable kernel persistence with validation after normalization on save and + independent native validation on load. Unsupported kernels must fail saving; + no silent Python-specific persistence fallback for this path. +- Interpreter-first semantics; JIT is optional and may fall back before execution. + +## Inventory: prioritize semantic difficulty + +| Feature | Current implementation evidence | Portability work / difficulty | Agreed feature-level disposition | +| --- | --- | --- | --- | +| Block reductions inside kernels | Native DSL admits top-level reductions and reductions in conditions; rejects reductions inside control-flow bodies (`src/dsl_compile.c`). | **High.** Explicit block grouping, masking, scalar outputs/broadcast, accumulation order, empty blocks and padding. | Include limited reductions over the current evaluation block, including Mandelbrot `all` conditions. Exclude unsupported reductions inside control-flow bodies; no implicit full-array reduction. | +| External functions and closures | Native `me_variable` supports registered C functions/closures. Python authoring allows named calls syntactically; native compilation determines availability. | **Very high.** Function implementation identity/version, state, ABI, registration, and reproducibility cannot be represented by process-local pointers. | Exclude externally registered functions, callbacks, and opaque captured objects. Allow supported builtin functions and typed constant snapshots. | +| Complex arithmetic | Native complex types exist, but Windows rejects them because of complex ABI incompatibilities (`doc/data-types.md`, `doc/windows-limitations.md`). | **High.** Portable representation, branch cuts, non-finite behavior, promotion, and a functioning interpreter across target platforms. | Exclude complex inputs, intermediates, outputs, and constants for 1.0. This is a real reduction from the full native language. | +| Observable side effects | Native DSL implements `print`, restricted to uniform/scalar values. Arbitrary Python I/O is not native DSL. | **High for deterministic behavior.** Ordering and repetition depend on block scheduling, parallelism, partial evaluation, and repeated lazy evaluation. | Exclude `print` and external effects from portable kernels. Do not silently strip them. Host diagnostics remain execution policy. | +| Numeric promotion and conversions | Current DSL supports arithmetic, casts, mixed operands, predicates, and math more broadly than portable 0.1. | **High but essential.** Define intermediate/result types, literal typing, division, casts, predicate rounding, and a bounded supported function list. | Include ordinary real/integer/Boolean numerical use cases; interpreter-first. Do not promise all native numeric combinations automatically. | +| ND index/shape symbols | `_flat_idx`, `_i`, `_n`, `_ndim` already have native synthesis and Python constructor tests. | **Medium-high.** Explicit logical shape, evaluation region, origin/coordinates, slicing/view interpretation, broadcasting and padding rules. | Include a defined ND-context capability; do not expose physical chunk layout as logical semantics. Unsupported host contexts must reject. | +| Fixed-width strings and bytes | Native string locals/returns, width inference, comparisons, concat, transforms, substring and split operations; Python string DSL tests. Interpreter-only today. | **Medium-high.** Typed widths, endianness/code units, constants, first-NUL semantics, truncation, Unicode mapping version and whitespace tables. | Include a bounded fixed-width string/bytes capability. Existing operations are candidates, not all certified yet. | +| Variable-length string representation | Native `me_eval_varlen()` packs evaluated fixed-width values into Arrow-style offsets/data. Intermediates stay fixed-width. | **Medium for an adapter; high for a new language type.** Layout, capacity, offsets and ownership versus dynamically sized intermediates. | Defer a portable varlen ABI/type. Do not reject a fixed-width kernel merely because its host stores the result as varlen. | +| Authoring conveniences | `_NumpyAttrCallRewriter`, `_StringSyntaxRewriter`, `_RowSubscriptRewriter` in `dsl_kernel.py`. | **Low-medium.** Correct normalization, name resolution, evaluation order, typed captures and explicit column mappings. | Include supported normalization: `np.sin(x)`, string methods/membership/split sugar, static `row["col"]`. Dynamic DataFrame operations are not an existing native DSL feature. | +| Persisted graph and storage bindings | `b2objects.py` and `lazyexpr.py` preserve sources and operand references; reconstruction still uses `kernel_from_source`. CTable has DSL-backed column round trips. | **High integration scope.** Kernel portability does not define remote access, authentication, recursive graph execution, or storage identity. | Integrate portable kernel payloads and explicit bindings in the host container. Exclude arbitrary Python-object persistence; do not claim all host graphs/storage protocols are portable. | + +## Agreed exclusion list + +These are the kernel exclusions for the first public release: + +1. **Unsupported reductions inside control-flow bodies and implicit global + collectives.** Permit top-level reductions and supported reduction conditions, + including an `if all(...)` condition within a loop. This is distinct from a + reduction assignment/return inside the body. No implicit reinterpretation of + block reductions as full-array reductions. Classify operations by semantics: + elementwise `fmin`/`fmax` are not block reductions. +2. **Externally registered functions, closures, and runtime object dependencies.** + No function pointers, Python callbacks, opaque object captures, or implicit + module/global state. Supported scalar captures become immutable typed values; + arrays/columns become explicit host bindings rather than hidden captures. +3. **Complex-valued computation.** Defer until there is a portable cross-platform + interpreter contract, independently of JIT availability. +4. **Observable kernel side effects**, including native `print`. Host tracing is + not a persisted kernel effect. +5. **Non-strict FP semantic modes** (`fast`/`contract`) for the initial contract. + Strict arithmetic and explicitly documented math-function accuracy are the + baseline; this does not imply bitwise-identical transcendental results across + all platforms. Persist semantic requirements, not compiler paths or caches. +6. **Dynamically sized intermediate/output types and arbitrary memory access.** + Retain statically bounded string widths and explicit output cardinality + (elementwise or supported block-scalar reduction). + General gathers/scatters, mutation of inputs, arbitrary array subscripting, + and dynamically selected columns are not new 1.0 features. Several of these + are already outside today's DSL; distinguish them from lost capabilities. + +Separate exclusions from the *artifact/host scope*: generated machine code, +Python source execution on import, pickled runtime objects, external function +registration protocols, and universal graph/remote-storage execution. Saving a +portable kernel in a LazyArray does not itself make every referenced data source +available in C or another language. + +## Block-local reduction contract to specify + +The reduction group is the **current evaluation block**, not the full logical +array. Partition-dependent results are permitted; reproducing those results +requires preserving the evaluation partition. The persistence/host integration +must record or unambiguously reconstruct that partition, not silently retile it. +Logical ND coordinates and physical evaluation grouping remain distinct concepts. + +The mandatory motivating case is `if all(escape_iter != limit): break` in the +Mandelbrot loop. It is a block-level early-exit optimization, not an array-wide +synchronization primitive. Conformance must test different partitions and show +both this use case and a deliberately partition-dependent reduction result. + +The approved policies below settle valid-element/active-mask participation, +empty identities, scalar broadcast, partition preservation, and ordered sums. +Before freezing, complete output-cardinality and per-operation details. +Masked/nested conditions that current implementations cannot +define consistently must be identified explicitly, not accidentally admitted. + +## Hard numeric domains: not syntactic exclusions + +Overflow, non-finite/out-of-range integer casts, division by zero, and invalid +shift counts depend on runtime values. They cannot generally be detected by a +save-time validator. Do not claim that successful persistence proves their +absence. The agreed rules below require runtime errors for the specified invalid +integer operations and conversions, and IEEE-style floating behavior. Implement +those checks rather than relying on caller preconditions for these cases. + +Likewise, unsigned integers, narrower widths, and each math builtin need an +explicit type/function matrix. They are open inventory decisions, not covered +by a blanket claim of full miniexpr compatibility. Real arithmetic remains a +major specification task even with limited reductions and no complex numbers. + +## What should not be excluded merely to save JIT work + +- Integer-input division, supported mixed numeric inputs, nested casts and + arithmetic predicates, once their interpreter semantics are defined. +- An agreed set of math builtins and elementwise `where`. +- ND symbols supplied through a defined logical context. +- Fixed-width Unicode/bytes kernels, including bounded string returns. +- Static column access and supported NumPy/string authoring sugar after lowering. + +For example, the existing row rewrite accepts a single row parameter used only +as `row[]` and records parameter-to-column mappings. It is not a +general translation of arbitrary `df[expr]` indexing. + +## Evidence and documentation gaps + +- `../miniexpr/doc/dsl-syntax.md`: statements, ND context, string locals/returns, + registered functions, reductions and print. +- `../miniexpr/doc/strings.md`: UCS4 versus bytes, NUL termination, width bounds, + Unicode truncation, and the existing varlen output adapter. +- `../miniexpr/src/dsl_compile.c`: actual reduction restrictions; existing + unsupported combinations are not an additional portable-only limitation. +- `src/blosc2/dsl_kernel.py`: authoring validator and normalization boundaries. +- `tests/ndarray/test_dsl_kernels.py`, `tests/ndarray/test_string_output.py`, and + `tests/ctable/test_ctable_dsl_columns.py`: ND, string, and persistence use cases. +- `src/blosc2/b2objects.py`, `src/blosc2/lazyexpr.py`: existing persistence paths. + +Some references disagree: Python's DSL page still describes reduction-in-body +behavior as silently incorrect, while current native compilation rejects it; +the strings guide's scalar-condition wording also needs reconciliation with +masked string DSL behavior. Resolve against implementation/tests before freezing +normative text. This inventory is a source review, not new feature certification. + +## Agreed semantic and compatibility decisions + +The following choices were approved after the feature-level scope discussion. +They govern portable 1.0; they are not claims about existing full-DSL behavior. + +### Numeric computation + +- Operand types and explicit casts determine intermediate computation; output + conversion happens last. An output dtype must not change the calculation. + In particular, float32 `(x + 1.0) - x` computes in float32 even when the output + is float64. Apply the new rules through the versioned portable path without + silently redefining ordinary full-DSL execution. +- Literals adopt the operand type where representable; otherwise use explicit + documented promotion rules or reject unrepresentable literals. Mixed typed + operands follow one enumerated promotion table. +- Integer `/` produces float64; homogeneous float32 division stays float32. +- `int(expr)` evaluates its argument first, then truncates toward zero. +- Boolean arithmetic uses numeric zero/one. Explicit `bool()` and Boolean output + perform truth conversion. +- Integer overflow, out-of-range integer narrowing, non-finite/out-of-range + float-to-integer conversion, integer floor-division/remainder by zero, and + invalid shift counts are runtime errors. +- Floating arithmetic retains IEEE-style NaNs, infinities and signed zero, + including floating division by zero. Enumerate math-function domain behavior + and accuracy guarantees separately; strict does not imply universally + bitwise-identical transcendental results. +- JIT must implement the same checks and semantics or fall back before execution. + +### Block reductions + +- Reductions consume valid, currently active lanes of the evaluation block. + Top-level reductions see all valid block elements. Supported nested conditions + see their participating lanes; exclude padding and lanes that have returned + or left the relevant loop. +- `any(empty)` is false, `all(empty)` is true, and `sum(empty)` is zero. + Empty `min`/`max` is a runtime error. Specify other admitted reductions in the + operation matrix before freezing. +- A reduced scalar controls or broadcasts only to participating lanes. +- Persist the logical evaluation partition independently of physical storage. + Rechunking must not silently change reduction groups. Partial reads evaluate + the original groups needed for the slice, then select requested results. + Explicit repartitioning may change results and must be described as such. +- Specify accumulation dtype and logical lane order for floating sums; initially + exclude reassociation into a different reduction tree. Integer accumulation + obeys checked-overflow rules. Relaxed reductions are a later capability. + +### Persistence and legacy formats + +- New DSL-kernel saves normalize authoring syntax/captures, validate portable + 1.0, and persist the artifact, bindings and required execution context. +- Unsupported kernels fail saving with actionable diagnostics; there is no + silent fallback to Python-specific persistence. +- Detect legacy persisted kernel formats and require explicit opt-in before + using them, through the applicable deserialization policy. Never execute + legacy Python reconstruction merely to detect the format. +- **No migration tooling or automatic conversion path is in scope.** Users who + want a portable 1.0 artifact must follow the guidelines, manually adapt their + kernels/bindings, and save through the validated 1.0 path. Legacy opt-in is + permission to use the old representation, not a claim of portable compliance. +- Publication guidance must document supported operations, the numeric behavior + change, reduction grouping, and legacy opt-in/manual adaptation. + +## Remaining specification drafting + +Implementation-led drafting can cover schema fields, capability negotiation, +typed encodings, explicit column bindings, existing ND coordinate conventions, +string width/Unicode rules, diagnostics, and compact conformance scenarios. +Use verified interpreter behavior as evidence, not inconsistent documentation or +an accidental backend behavior as the normative contract. + +The policy choices above are settled. Draft the exact promotion table, literal +representability rules, function/type matrix, reduction NaN behavior and +accumulation dtypes, mask transitions, partition encoding, and legacy format +discriminators/opt-in API against them. Surface contradictions or additional +compatibility consequences for review rather than changing approved policy. + +Draft an explicit dtype/function matrix based on current use cases; surface any +proposed omission of an existing useful operation for review. Pin string mapping +behavior and document truncation rather than silently redesigning it. Do not +promise bitwise-identical transcendental results without an implementation that +can deliver them. + +## Bounded acceptance gates + +1. Draft and review the detailed 1.0 semantics, type/function matrix, capability + requirements, and detailed rules implementing the agreed decisions above. +2. Implement native validation and interpreter conformance for those contracts; + reject unsupported kernels with actionable diagnostics. +3. Integrate portable payloads in kernel persistence, preserving typed bindings, + ND context and reduction partition requirements. Verify standalone C loading + without Python reconstruction, plus host save/load round trips. +4. Certify supported platforms. JIT must preserve the contract or select fallback + before execution; additional acceleration is not a release gate. + +Keep tests orthogonal and retain native ownership of exhaustive language fixtures. +Scope changes require explicit agreement; do not restart a whole-language JIT audit. diff --git a/plans/portable-DSLs-first-version.md b/plans/portable-DSLs-first-version.md new file mode 100644 index 000000000..d2deb0e8c --- /dev/null +++ b/plans/portable-DSLs-first-version.md @@ -0,0 +1,841 @@ +# Portable DSL v0.1: first implementation plan + +**Status: conservative 0.1 boundary frozen; release integration in progress.** +The normative specifications are `../miniexpr/doc/dsl-spec/0.1.md` and +`artifact-0.1.md`; the development history below is not the current release scope. + +### Closed scope and release checklist + +- Native source and compiled-tree gates exclude transcendental calls, nested + numeric casts, floating expression arguments to truth casts, mixed computation + intermediates, and unlowered float32/division predicate arithmetic. +- Overflow, out-of-domain casts, zero divisors, and non-default rounding are + explicit runtime-domain exclusions, not promises of wraparound or trapping. +- `frozen-excluded.txt` separates preserved full-language regressions from + conformance. Negative tests verify validation, export, and native import; + unsupported artifacts cannot enter via a bypassed authoring frontend. +- Python package builds enable the optional native artifact adapter by default, + retaining an explicit OFF build option and including yyjson's MIT license. +- Native frozen revision published: `7543a9592410bdfd72f7a7319343dfece55b09e4`. + Python pins that immutable revision, including platform test-harness fixes. +- Stock wheel verification passed without a local native source override: + artifact support defaults ON, yyjson's license is included in wheel metadata, + and interpreter/JIT execution works after moving the build tree. The isolated + wheel passed 2171 focused Python tests; local native and sanitizer suites passed + 431 and 340 tests respectively. Documentation builds with pre-existing warnings. +- Host CI now enables native artifacts on Linux/macOS/Windows and ARM64 jobs. + Local certification is macOS arm64; other platform jobs must be green before + announcing cross-platform release certification. +- Windows conformance certifies the interpreter baseline, not TCC acceleration. +- Numeric scope is closed. Broader math/casts, overflow policy, arbitrary mixed + promotion, and lazy/container integration are later-profile work, not 0.1 gates. + +### Implementation progress + +The first raw-source slice is implemented across Python-Blosc2 and `../miniexpr`: + +- Draft native profile: `../miniexpr/doc/dsl-spec/0.1.md`. +- Native-only Python constructor: `blosc2.DSLKernel.from_source(source)`, with no + Python `exec`, captures, frontend rewriting, or Python-function fallback. +- Shared finite-float64 fixtures and standalone C runner: + `../miniexpr/tests/portable-dsl/`, covering branches, chained comparisons, + bounded loops, and reordered native input bindings. +- Native compiler selection now honors explicit source pragmas ahead of the + `ME_DSL_JIT_COMPILER` environment default, with regression tests. +- Interpreter-only and bundled-TCC build configurations exercise the corpus; + required-JIT tests reject silent fallback. + +The reviewed native baseline is miniexpr revision +`a1f845b590582a85e5fac04184f3f4758e7ca9a5`. Python-Blosc2's existing dependency +pin is unchanged; its installed extension and the authoritative native checkout +are tested independently. Integrating the updated native dependency remains +necessary before claiming the precedence change in distributed Python builds. + +This is **not yet the full v0.1 completion gate**: the wider dtype/semantic audit, +artifact packaging/integration and the remaining semantic audit +are still pending. The raw-source constructor accepts native DSL, not only the +draft portable subset. No new dependency or persisted artifact format has been +introduced. + +Native profile validation is now implemented as `me_validate_portable_dsl()` in +`../miniexpr/src/dsl_portable.c`, with a structured status and optional diagnostic. +It filters native parsed source, checks an explicit homogeneous-input signature, +then compiles with JIT disabled without evaluating a kernel. The corpus runner +uses it before execution. `blosc2.validate_portable_dsl()` exposes the same check +through the extension, with no Python parser/rewriter fallback; older native builds +report `runtime_unsupported`. The local editable environment is rebuilt against +the authoritative checkout via `FETCHCONTENT_SOURCE_DIR_MINIEXPR`; the repository +dependency pin remains unchanged. The draft spec now documents the exact initial +feature filter and distinguishes validation from runtime constraints, backend +compatibility, numerical-accuracy certification, and trust/resource policies. + +Validation for this slice passed: 137 full native tests, 70 conformance/validation +tests with bundled TCC disabled, 24 AddressSanitizer checks, and 210 focused Python +tests with standalone native-runner comparisons enabled. Ruff and diff whitespace +checks passed; the native builds emitted no new compiler warnings. + +P3 now has a candidate artifact schema in `../miniexpr/doc/dsl-spec/artifact-0.1.md` +and a separate optional `miniexpr_artifact` C adapter. With user approval, it uses +yyjson 0.12.0 pinned to `8b4a38dc994a110abaec8a400615567bd996105f`; the raw compiler +does not fetch/link yyjson when `MINIEXPR_BUILD_ARTIFACT` is OFF (the default). +The adapter validates strict JSON structure and duplicate keys, versions and +capabilities, typed scalar encodings, entry point and exact binding coverage, +and portable-profile compilation. It owns source/names/scalars, binds runtime +buffers by name, broadcasts constants in bounded tiles, and separates load, +binding, native evaluation, and allocation failures. Required strict FP semantics +are made explicit on an internal source copy when no FP pragma is supplied; +retained compiler pragmas remain preferences rather than compatibility requirements. +The hand-authored affine artifact runs in the standalone C runner without Python. +The schema/profile remain experimental; native adapter packaging and the remaining +semantic audit are still pending. P4 integration is described below. + +P3 validation passed: 143 full native tests, 75 conformance/validation/artifact +checks with bundled TCC disabled, 29 AddressSanitizer checks, and 210 focused +Python regression tests. A fresh static-only raw-compiler build without artifact, +SLEEF, TCC, or Accelerate dependencies passed 70 conformance/validation checks; +yyjson was not fetched. The adapter and tests also passed `-Wall -Wextra -Werror` +syntax checks. A test-only deprecated `sprintf` warning was fixed; final native +builds emitted no new compiler warnings. + +P4 now exposes `DSLKernel.export()` and `PortableKernel.from_json()` / +`evaluate()` in Python. Export uses the unspecialized author's DSL source and +snapshots exact supported scalar globals/closure values into collision-free +parameters and typed constants. Explicit parameter constants and capture dtype +overrides are supported; no user conversion hooks or kernel calls are used. +Input/output dtypes are explicit and portable native validation plus the C loader +validate every exported artifact. Import calls that same loader through an owned +Cython handle, without Python source/JSON parsing or frontend preparation. +Runtime input names/dtypes/shapes are checked, host storage is adapted, and native +constant broadcast/evaluation is reused. NumPy-alias rewriting now excludes local +and closure shadowing so export cannot silently reinterpret a local attribute call. +The extension links the adapter only if the optional native target is available; +disabled/older builds report unsupported artifact operations. Local builds use +the source override and `MINIEXPR_BUILD_ARTIFACT=ON`; the repository dependency pin +is unchanged because native dependency publication/integration is still pending. +Artifact execution is currently eager NumPy output, not lazyudf/container integration. + +P4 validation passed: 240 focused Python tests with the adapter enabled, including +Python export -> standalone C execution, fresh-process import without the author, +typed scalar boundaries/NaN payloads, snapshot/collision/closure handling, storage +adaptation, native diagnostics, and concurrent interpreter/TCC evaluations. +An actual adapter-disabled editable build passed 212 tests with 28 artifact-only +cases skipped and verified `NotImplementedError` without a Python fallback. +The environment was restored to the adapter-enabled local build. The native +conformance/profile/artifact selection passed 99 checks; Ruff, the standalone +example, and whitespace checks also passed. + +The next conformance slice expands the shared corpus with explicit +input/output dtypes and expected compile/evaluation outcomes. It covers all five +candidate dtypes, exact int64 boundaries and comparisons above `2**53`, signed +zero and non-finite identity, Boolean-result semantics, bounded loop control, +small finite casts, and sampled `sin` results. Integer fixtures are decoded and +compared without a floating-point intermediate. CTest also generates CC variants +that change only the compiler preference, uses build-local JIT caches, and applies +timeouts. Missing-return kernels now have runtime JIT support: successful paths, +mixed successful/failing elements, loop returns, and hybrid vector cleanup are +tested under required-JIT policies. Semantic missing-return errors propagate +without interpreter retry; generic backend failures retain existing fallback. +This advances P2 coverage but does not freeze +overflow, general promotions/conversions, or global transcendental accuracy rules. + +The numeric stabilization slice adds 25 shared exact output-conversion fixtures +(the full supported 5×5 dtype matrix), including representable cast boundaries, +int64 rounding, signed zero, subnormals, and non-finite identity/truth values. +Native integer-literal validation now checks normalized digits exactly so +`2**53 + 1` cannot bypass the profile limit through double rounding. +The audit found unresolved integer-valued division promotion and float32 math +intermediate/condition discrepancies across JIT and linked interpreter paths. +Shared reproducers and strict expected-failure artifact tests preserve the gaps; +they block freezing rather than redefining portable semantics. Details are in +`../miniexpr/doc/dsl-spec/numeric-audit-0.1.md`. Native publication, dependency +integration, and the rest of the semantic matrix remain pending. + +This slice passed 328 focused Python tests with 10 strict expected JIT failures, +202 native portable/profile checks in the TCC-enabled build, and 55 selected +interpreter-only portable/profile/artifact checks. Ruff and whitespace checks +passed, and the native builds emitted no new warnings. + +The next slice corrects the first division-promotion cases using C arithmetic +rendered from the native compiled expression tree. Seven exact shared fixtures +cover leaf casts, literal folding, locals, loop indices, float32 rounding, and +branch conditions under interpreter/TCC/CC execution. Typed text participates in +the IR fingerprint and code-generation cache version 14. Text-only hybrid plans +cannot bypass the correction. Unsupported typed contexts conservatively retain +interpreter execution; native-only artifact import and compiler precedence are +unchanged. The six division expected failures are removed; four float32 math +expected failures remain. Broader nested-cast probes exposed additional native +evaluator dispatch anomalies and an unisolated abort, recorded in the numeric +audit as separate blockers rather than promoted conformance claims. + +Division-slice validation passed 377 focused Python tests with four remaining +math expected failures, all 272 native tests in the TCC-enabled build, and 61 +selected interpreter-only portable/profile/artifact/IR/codegen tests. Required-JIT +division fixtures passed under both TCC and CC. Ruff and whitespace checks passed; +native builds emitted no new warnings. At that stage the nested-cast reproducer +was excluded from execution conformance pending a native evaluator investigation. + +The following memory-safety slice isolated that abort with AddressSanitizer: +nested conversion code selected a float64 writer for a float32-sized scratch +buffer. The writer now matches the actual typed evaluator's output representation +while retaining source-dtype evaluation. Exact interpreter fixtures and native/ +Python tests cover float32/float64 input/output pairs, counts 1/5/257, repeated +evaluation, and requested-JIT fallback. Sanitizer validation also corrected an +existing mixed-type test's undersized output allocation (int32 + float32 infers +float64). All 217 sanitizer-build tests, all 274 regular native tests, and 401 +focused Python tests passed, with four existing math expected failures. Ruff and +whitespace checks passed; builds emitted no new warnings. This fixes the confirmed +buffer overflow, not broader nested-cast promotion or float32 math semantics; +those still block freezing 0.1. The native dependency pin remains unchanged. + +The next slice corrects `int()`/`bool()` argument value semantics: evaluate in the +argument's compiled dtype before truncation/nonzero truth, instead of promoting +variables or recomputing arithmetic in the cast result dtype. Integer casts +preserve int64 values beyond `2**53` without a double round trip; Boolean casts +retain non-finite and subnormal truth. Five exact shared fixtures require real +TCC/CC execution as well as interpreter agreement; a separate division audit +case checks conservative interpreter fallback. Native repeated-evaluation tests +cover counts 1/5/257 and floating widths, while Python tests cover all five output +dtypes for value casts. All 295 regular native tests, 233 AddressSanitizer tests, +and 484 focused Python tests passed, with four existing math expected failures. +No new build warnings were emitted. General `float()`/division promotion, +out-of-domain integer casts, and float32 math semantics remain unfinished; the +profile is still experimental and the dependency pin remains unchanged. + +The following float32 math slice resolves the two remaining expected-failure +reproducers for leaf `sin` widening and `cos` branch conditions. Strict leaf +float32 sin/cos uses scalar float math at every count, avoiding the one-ULP SIMD +variation observed at count 257; comparison evaluation no longer pre-promotes +variables before consuming operand values. Owned typed JIT math text preserves +float rounding before widening/comparison and bypasses text-only hybrid plans; +it enters the IR fingerprint, with code-generation cache version 15. The two +audit fixtures are promoted to interpreter/TCC/CC conformance, with a local-value +widening fixture and native/Python repeated-execution checks at counts 1/2/257. +All 307 regular native tests, 242 AddressSanitizer tests, and 525 focused Python +tests passed without expected failures or new build warnings. General nested +math, other functions, inexact comparison constants, broader promotion/cast +domains, and cross-platform math accuracy still block freezing the profile; +dependency integration remains pending. + +The next literal/promotion slice corrects pure float32 arithmetic: C double +literals must not bypass native operand or intermediate rounding for `+`, `-`, +`*`, and unary negation. Five shared exact fixtures cover exact/decimal literal +rounding, subtraction, locals, and differing floating output context. Literal +typing is contextual: a float64 requested output can make literal-containing +arithmetic compute in float64, rather than just widen a float32 result. The new +owned lowering targets float32 computation only, bypasses text-only hybrid plans, +enters the IR fingerprint, and uses code-generation cache version 16. Ordinary +float64 hybrid branch optimizations are preserved. Native/Python tests check +counts 1/5/257, repeated execution, both floating output widths, and scalar +addition/subtraction/multiplication. All 328 regular native tests, 258 +AddressSanitizer tests, and 632 focused Python tests passed without expected +failures or new build warnings. Calls/casts, mixed intermediate dtypes, integral/ +Boolean arithmetic, overflow, and the complete promotion contract remain audit +work; the profile is still experimental and dependency integration is pending. + +The while-loop execution-policy slice fixes missing JIT cap enforcement. Scoped +body-entry counters preserve exact-limit exits, `continue`, nested/re-entered +loops, and condition-prefix lowering. The normalized host cap enters the IR +fingerprint, with code-generation cache version 17; a changed policy after +compilation bypasses both JIT evaluation paths for current-policy interpreter +execution. Semantic cap errors propagate without interpreter retry and release +hybrid temporaries. Four shared fixtures and expanded native/Python tests cover +small caps, disabled/invalid policies, counts 1/5/257, repeated/empty execution, +cache isolation, policy changes, and boundary control flow. A separate +interpreter mixed-lane chained-while discrepancy is preserved in +`audit/while_cap_chain` and a strict expected-failure test; it blocks freezing +the profile alongside the remaining numeric domains and dependency integration. +Validation passed all 344 regular native tests, 270 AddressSanitizer tests, and +727 focused Python tests with one strict chained-while expected failure. Ruff +and whitespace checks passed; native builds emitted no new warnings. + +The subsequent masked-local correction resolves that chained-while discrepancy. +Scalar chain operands now read the active lane of local buffers rather than +assuming compile-time uniformity survives masked updates. Root reduction copies +broadcast their scalar results into full-width DSL destinations, preserving +existing nonportable reduction behavior. `while_cap_chain` is promoted to the +passing corpus, with numeric/Boolean masked-local fixtures and expanded lane, +dtype, count, and repeated-evaluation matrices. Validation passed 357 regular +native tests, 280 AddressSanitizer tests, and 895 focused Python tests without +expected failures or new native build warnings. The remaining numeric contracts +and publication/integration gates are unchanged. + +The next numeric slice fixes float32 rounding lost around same-dtype `float()` +calls: `(float(x) + 1.0) - float(x)` and `float(x + 1.0) - float(x)` now return +the interpreter's zero at `x = 2**24`, instead of JIT's previous one. Typed pure +arithmetic admits only float32-result calls with float32-computed arguments, +recursing through the already supported arithmetic. Root calls, nested/repeated +calls, and local assignments preserve rounding; float64 output retains observed +contextual literal semantics. Mixed/integral casts and general calls are not +certified. Four shared fixtures and expanded scalar/vector matrices cover both +compilers, output widths, decimal literals, signed zero, subnormals, extrema, +infinities, and NaNs. Code-generation cache version is 18. Validation passed all +373 regular native tests, 292 AddressSanitizer tests, and 1019 focused Python +tests without expected failures or new native build warnings. + +The Boolean-operand floating-arithmetic slice corrects interpreter storage: +`bool(x) + bool(x)` with integral inputs and floating output now returns two +for nonzero input rather than writing an invalid Boolean byte before conversion. +The DSL preserves the requested floating computation dtype for Boolean-inferred +arithmetic, while casts still consume their arguments in their own dtype. +Typed unary negation casts before operating so false produces floating negative +zero, including top-level bool-assigned locals. Float64 lowering stays narrow +to preserve hybrid branch/select plans; cache version is 19. Five shared fixtures +and direct/local scalar/vector matrices passed 393 regular native tests, +307 AddressSanitizer tests, and 2014 focused Python tests without expected +failures or new native build warnings. `audit/bool_output_fraction` preserves an +unresolved Boolean-output arithmetic discrepancy, not a normative rule; that +domain and broader mixed-type promotion remain publication gates. + +The next slice implements the user-selected numeric-then-truth Boolean contract. +Boolean operands are numeric zero/one, fractional literals and intermediates +stay numeric, and truth conversion occurs only at a Boolean output or explicit +`bool()` call. Boolean-only/integral-literal contexts compute in int64; +fractional-literal contexts compute in float64. Locals and cast arguments retain +numeric values, and a `2**53` cancellation regression checks exact integral +intermediates. `bool_output_fraction` is promoted from the audit corpus, with +four additional shared fixtures and scalar/vector backend matrices. Cache +version is 20. Validation passed 413 regular native tests, 322 AddressSanitizer +tests, and 2161 focused Python tests without expected failures or new native +compiler warnings. This closes the sampled Boolean-output discrepancy, not the +remaining arbitrary mixed-type promotion and overflow contracts. + +## 1. Goal and scope + +Establish a small, versioned miniexpr kernel language that executes independently +of Python, then demonstrate Python export and standalone C import of a portable +kernel artifact. Deliver this vertical slice before deciding how far to extend +the language, its packaging, or other language bindings. + +This implements the first stage of [the broader proposal](portable-DSLs.md), with +two refinements: + +- Native execution and cross-language conformance come before artifact design. +- Compiler pragmas remain in portable source and override local compiler defaults, + while retaining best-effort fallback. + +Python-like syntax is compatible with a language-independent standard. The +contract is a documented grammar and semantics, implemented without Python, not +the absence of syntax familiar to Python users. + +### Two independently useful deliverables + +1. **Portable source:** identical source plus an explicit signature can execute + through miniexpr's C API and Python-Blosc2. +2. **Portable artifact:** a small manifest carries that source, signature, typed + constants, and semantic requirements between environments. + +The first deliverable must not depend on completing the second. + +### Initial required scope + +- One named kernel, scalar-per-element execution, one scalar result per element. +- An explicit ordered input signature and output dtype. +- A documented subset of existing native numeric and Boolean syntax. +- Native interpreter execution as the mandatory baseline. +- TCC execution where supported, with tests proving which backend actually ran. +- Raw-source construction from Python without reconstructing a Python function. +- Python export of a kernel with a captured numeric scalar constant. +- A standalone C loader that consumes the exported artifact without Python-side + preparation at load time. +- Version checks, typed binding validation, and useful unsupported-feature errors. + +### Deferred beyond the initial completion gate + +- Complete string/bytes support and normalization of every authoring convenience. +- New method syntax, membership syntax, or split unpacking in miniexpr. +- Reduction kernels, index symbols, arbitrary rank constraints, and broadcasting. +- Complex, structured, object, datetime, nullable, and variable-length dtypes. +- External C functions, closures, and host callbacks in portable artifacts. +- `print` and other observable block-level side effects. +- Whole lazy computation graphs, array storage references, and remote access. +- Integration into Blosc2 persistence containers and generated-code caches. +- Mandatory JavaScript, Rust, or Julia implementations. + +Existing functionality outside this subset continues to work through existing +APIs; it simply is not certified by the initial portable profile. + +### Baseline after reviewing the updated miniexpr checkout + +The authoritative checkout is `../miniexpr`. Its existing `doc/dsl-syntax.md` +is already titled **miniexpr DSL Syntax (Canonical Reference)** and documents +native syntax and several exact semantic/error rules. `doc/dsl-usage.md` already +demonstrates standalone C compilation/evaluation and documents JIT controls. +This work standardizes a portable subset of that language; it does not introduce +native DSL execution from scratch or replace the existing reference. + +In particular, the full language already supports reductions, reserved ND symbols, +`print`, and string-valued kernels. Those features need explicit profile exclusions +in v0.1 rather than descriptions implying they are absent from miniexpr. + +## 2. Ownership and implementation boundaries + +### miniexpr owns the portable language + +Keep the normative specification, native validation, interpreter behavior, and +language conformance corpus with miniexpr. Its implementation is the initial +implementation of the specification, not an implicit substitute for one. + +Keep the kernel DSL distinct from miniexpr's classic expression API. Do not +silently expand or change that API when implementing portable kernel support. + +### Documentation layout and versioning + +Use these paths in the authoritative miniexpr repository: + +- `doc/dsl-syntax.md`: retain the current canonical reference for the full native + DSL. Extend or clarify it where the semantic audit finds omissions; preserve + its existing role and links from other documentation. +- `doc/dsl-usage.md`: retain the practical C API and runtime configuration guide. +- `doc/dsl-spec/0.1.md`: add the normative **portable profile** specification, + identifying the admitted grammar, dtype/function matrix, semantic requirements, + and explicit exclusions from the full DSL. +- `doc/dsl-spec/artifact-0.1.md`: add the versioned manifest and typed-binding + specification once the portable-source milestone works. + +During drafting, derive rules from the canonical reference rather than inventing +a second grammar. At publication, make the versioned profile's normative rules +self-contained or pin incorporated material to an immutable miniexpr revision. +A moving `doc/dsl-syntax.md` link must not silently change the meaning of a +published v0.1 artifact. Link from the current canonical reference to the profile +and explain full-language versus portable-profile support. + +Native work must be made in the authoritative miniexpr checkout and integrated +through the dependency mechanism used by Python-Blosc2. Build-tree copies under +`build*/_deps/` are inspection/build artifacts, not the source of record. + +### Python-Blosc2 owns authoring and integration + +Use `src/blosc2/dsl_kernel.py` as the integration point for current kernel +authoring, normalization, and capture handling. Inspect the existing extension +bridge before adding new native entry points. If artifact handling merits its +own module, use a non-underscored name such as `dsl_portable.py`. + +Separate the native specification from Python guidance in +`doc/reference/dsl_syntax.md`. Link to the normative miniexpr reference and clearly +identify decorator behavior and frontend-only conveniences. + +### Keep the layers independently testable + +1. Parse and validate native source against the portable profile. +2. Validate signature and typed bindings. +3. Check target semantic capabilities. +4. Compile or interpret using the selected execution preference. +5. Execute on caller-supplied buffers. + +Artifact decoding should feed these same operations. It should not introduce a +second language validator or execute frontend rewriting at import time. + +## 3. Define the initial language profile + +Use separate identifiers for the language version and artifact schema version. +Suggested initial values are `0.1` for each; these are experimental compatibility +identifiers, not miniexpr package versions. + +### Candidate core, to freeze after the native audit + +- One top-level `def`, positional named parameters, indentation-based blocks. +- Local assignments, supported compound assignments, and `return`. +- `if`/`elif`/`else`, `for ... in range(...)`, bounded test cases for `while`, + `break`, `continue`, and `pass`. +- Native numeric literals, arithmetic, comparisons, chained comparisons, and + Boolean operators. +- A short, explicit whitelist of native casts and mathematical functions. +- Comments, docstrings, semicolons, and multiline syntax already accepted natively. +- Initially target `bool`, `int32`, `int64`, `float32`, and `float64`; include only + types and operations whose behavior is specified and verified across the + interpreter and supported JIT paths. Do not claim unsigned or mixed-type support + merely because a host API accepts the dtype. + +Start the first executable fixture with `float64`; expand to the frozen core +before declaring v0.1 complete. Record the final operator/function/type matrix in +the normative specification rather than relying on this candidate list. + +### Semantic decisions required before freezing the profile + +Document and test: + +- Parameter binding, duplicate names, local assignment and type inference rules. +- Literal typing, promotions, return conversion, and explicit casts. +- Integer overflow, narrowing, signed division, remainder, and division by zero. +- Floating-point rounding assumptions, non-finite values, and signed zero. +- Evaluation order, single evaluation of chained operands, and short-circuiting. +- Boolean-result rules for `and`/`or`, without implying Python operand-return rules. +- Loop bounds, step handling, and errors such as a zero `range` step. +- Missing returns and use of uninitialized locals. +- The scalar-per-element execution model and independence from chunk boundaries. +- Error categories and when errors occur: validation, compilation, or execution. + +Carry forward the rules already documented in the native reference, verifying +them rather than treating them as undecided design choices: + +- Native parameters match variable names by set membership; caller variable order + may differ from source parameter order. +- Incompatible local reassignment and inconsistent return dtypes are compile-time + errors; an executed path without a return fails at runtime. +- A zero `range` step and exceeding the `while` iteration cap are runtime errors. + Specify the cap and its configuration/portability implications for this profile. +- `//=` lowers to `floor(a / b)`; do not assume Python integer floor-division + precision without auditing intermediate typing. +- Reserved ND names remain reserved even though index-aware kernels are excluded. +- The full DSL permits reductions at top level and in conditions, but not inside + `if`/`for`/`while` bodies. The v0.1 elementwise profile excludes reductions in + all positions, including conditions, to retain chunk-independent semantics. + +Audit existing behavior before promising a rule. If interpreter and JIT disagree, +either fix the discrepancy with regression coverage or exclude that operation/type +combination from v0.1. Do not standardize accidental C undefined behavior. + +Use a small core capability identifier rather than a capability for every token. +Add separate capabilities only for meaningful optional semantic features. Backend +names such as `tcc` are execution preferences, not language capabilities. + +## 4. Compiler preferences and interpreter baseline + +Miniexpr includes an interpreter. It also builds bundled libtcc by default on +supported targets, so ordinary users do not need a separately installed compiler. +TCC may be disabled in custom builds or unavailable on a target; Python-Blosc2 +currently disables it on Windows ARM64. + +For this implementation: + +1. Preserve `# me:compiler=tcc|cc` in portable source. +2. An explicit source pragma wins over the local compiler-selection default. +3. With no pragma, use the runtime's existing default selection policy. +4. Preserve existing best-effort fallback when the preferred backend is unavailable + or cannot compile the kernel. Use the interpreter when it satisfies the required + semantics. +5. Keep ordinary fallback quiet, while making the actual execution backend + observable to diagnostics and conformance tests. + +Audit the current selection path and codify its fallback order; do not invent a +new fallback chain as a side effect of artifact support. A deliberate local +interpreter-only execution mode remains useful for testing and deployments; it +is distinct from choosing a default compiler. + +Reuse the documented `ME_JIT_DEFAULT`, `ME_JIT_ON`, and `ME_JIT_OFF` policies, +including `me_eval_params.jit_mode`, rather than adding a parallel JIT toggle. +Test that explicit `ME_JIT_OFF` prevents JIT even with a compiler pragma: choosing +whether to JIT and choosing which compiler to prefer are separate controls. + +Floating-point requirements are independent of backend preferences. Define how +`# me:fp=strict|contract|fast` maps to the artifact's semantic requirements and +which interpreter/JIT modes satisfy them. Reject conflicting declarations rather +than silently allowing one to override the other. Do not promise identical bits +across all mathematical libraries or imply a stronger meaning of `strict` than +the specification defines. + +Compiler paths, cache directories, and diagnostic settings remain local. The +artifact contains a compiler preference, never instructions to locate or load an +arbitrary executable or library. + +## 5. Raw-source execution before packaging + +Build the first vertical slice around source such as: + +```text +# me:compiler=tcc +def affine(x, scale, offset): + y = x * scale + offset + if y < 0: + return 0.0 + return y +``` + +At this stage all three names can be ordinary explicitly typed inputs. Execute +the exact same source through a standalone C program and Python, using the same +input values and declared output type. + +Expose or reuse a Python raw-source construction path that accepts source and a +signature. Loading it must not use Python `exec`, fabricate a Python function, or +inspect globals. Final public names should follow the existing kernel API after +inspection; do not add competing constructors unnecessarily. + +The C executable must link miniexpr without libpython. Python may launch it as a +test subprocess, but the executable must also run directly from a shell with +prepared fixtures. Native execution requires no Python-generated temporary code. + +Start from the existing `me_compile()` / `me_eval()` / `me_free()` flow documented +in `doc/dsl-usage.md`; use `me_compile_nd_jit()` where its explicit JIT controls +are needed. Audit existing parser diagnostics and backend test helpers before +introducing any new native API. The new work here is a reusable conformance runner +and profile validation, not a replacement execution engine. + +## 6. Minimal artifact design + +After raw-source conformance works, use a standalone UTF-8 JSON manifest as the +first interchange format. Keep it small enough for a native loader and independent +of Blosc2 storage. Reassess container integration after v0.1 works end to end. + +### Proposed fields + +| Field | Meaning | +| --- | --- | +| `schema_version` | Artifact encoding/structure version | +| `language` | Language identifier and version | +| `requires` | Required semantic capability identifiers | +| `source` | Complete canonical native DSL source, including retained pragmas | +| `entry_point` | Name of the single kernel in the source | +| `inputs` | Ordered runtime input names and language-neutral dtypes | +| `constants` | Explicit named, typed scalar bindings | +| `output` | Output dtype and scalar-per-element execution contract | +| `semantics` | Required floating-point profile and other supported requirements | +| `metadata` | Optional non-semantic producer information | + +Freeze required fields and unknown-field handling in a small schema document. +Reject duplicate JSON keys, duplicate bindings, and unknown semantic fields. +Permit explicitly designated informational metadata without interpreting it. +Do not introduce a runtime schema-validation dependency just for this manifest. + +### Signature and constants + +Use the source's parameter list as the full native parameter order. Every +parameter must be supplied exactly once by either `inputs` or `constants`. +Disallow overlapping names, missing bindings, and unused binding entries. +`inputs` follows source order with constant parameters omitted. + +This ordering is an artifact convention, not a new native-language restriction. +The adapter must map names to the `me_variable` array and supply evaluation +pointers in that array's order, as the current native API requires. Include a +reordered-variable fixture to prevent accidental positional-only binding. + +For captured constants, export a collision-free explicit parameter and record its +typed value in `constants`. This avoids reliance on implicit native globals or +Python literal formatting. Reuse native scalar binding support if available; +otherwise provide an adapter with defined broadcast and lifetime behavior rather +than exposing an array-sized copy requirement in the artifact contract. + +### Typed scalar encoding + +- Boolean: JSON Boolean with dtype `bool`. +- Integer: decimal string with explicit fixed-width dtype and range validation. +- Float: exact IEEE-754 bit-pattern hex string with explicit `float32` or + `float64` dtype and fixed digit count, written most-significant byte first. +- Decode floats into the host representation explicitly; do not rely on native + endianness or JSON numeric precision. + +This preserves large integers, signed zero, infinities, and NaNs in transport. +Transporting a NaN bit pattern does not promise that arithmetic preserves its +payload. Strings/bytes get a separate encoding decision when that profile is added. + +### Compatibility + +For the experimental implementation, accept only explicitly supported language +and schema versions. Reject unknown versions clearly instead of guessing forward +compatibility. Keep frozen example artifacts as regression fixtures. Once a v0.1 +contract is published, change semantics under a new version rather than silently +reinterpreting existing artifacts. + +## 7. Python export and import + +### Export pipeline + +1. Obtain the existing author's source and explicit specialization signature. +2. Normalize supported frontend conveniences using the existing frontend machinery. +3. Discover scalar captures without calling the kernel or arbitrary user callbacks. +4. Resolve each supported capture to an explicit dtype and snapshot its value at + export time. Require an explicit type when inference would be ambiguous. +5. Replace captures with collision-free bound parameters. +6. Run native portable-profile validation on the resulting source and signature. +7. Derive required capabilities and emit the manifest deterministically. + +Do not treat `kernel.dsl_source` alone as the finished artifact. Audit whether +existing normalization or scalar specialization has already discarded type or +capture information; retain that information before lowering if necessary. + +The first required example captures a numeric scale constant. After export, +changing the Python global must not change execution of the saved artifact. +Reject unresolved names, arrays/objects as captures, external functions, and +unsupported constructs with the relevant name and source location where possible. + +### Import pipeline + +Decode and validate the artifact, construct the typed bindings, then use the same +native source path as C. Import must not require the original module, function, +decorators, globals, or frontend rewriters. + +Provide a raw-source portable validator first. An optional strict authoring mode +that rejects frontend sugar and implicit captures can build on it later; it need +not block the first export/import milestone. + +## 8. Native artifact loader + +Implement the loader as a thin adapter adjacent to miniexpr's native API, with +clear ownership of decoded source, binding buffers, compiled handles, and errors. +The language compiler must remain usable without JSON artifact support. + +Before choosing JSON machinery, inspect existing dependency policy and available +parsers. Reuse an appropriate existing facility where possible; any new dependency +requires an explicit decision. Avoid a hand-written partial JSON parser that only +accepts the Python exporter's preferred formatting. + +Loader stages: + +1. Decode JSON with bounded lengths and validate field structure. +2. Check schema/language versions and required capabilities. +3. Decode and range-check typed constants and signature information. +4. Validate entry point and exact binding coverage against native source. +5. Check semantic requirements independently of the compiler preference. +6. Construct an executable handle using the existing interpreter/JIT machinery. +7. Bind caller-provided data and execute; free all owned resources on every path. + +Define logical buffers as same-length inputs and output for the initial profile, +with scalar constants broadcast to each element. Specify empty-input behavior, +host dtype conversion, buffer ownership, and binding lifetime. Keep physical +strides, endian conversion, and storage layout in adapters rather than in source. + +Distinguish malformed artifacts, unsupported requirements, invalid source, +binding errors, and evaluation errors. Lack of the preferred compiler alone is +not an invalid artifact. + +The loader does not provide a sandbox. It must not execute Python, follow artifact +paths to load libraries, or use artifact data as shell commands. General resource +isolation remains a host responsibility rather than a new v0.1 subsystem. + +## 9. Conformance corpus and verification + +Create language-neutral fixtures containing source, signature, inputs, expected +outputs or error category, and numeric comparison rules. Keep native language +fixtures authoritative in miniexpr and consume the same cases from Python tests; +avoid independently maintained copies with diverging expectations. + +Seed the corpus from existing native tests, especially `test_dsl_syntax.c`, +`test_dsl_python_syntax.c`, `test_dsl_literals.c`, `test_dsl_comparisons.c`, +`test_dsl_bool_locals.c`, `test_dsl_guards.c`, and `test_dsl_jit_options.c`. +Reuse their helpers where appropriate and preserve implementation-level coverage; +only promote profile-relevant cases into the shared language-neutral corpus. + +Required groups: + +- Basic arithmetic, branches, loops, casts, and every admitted dtype/function. +- Chained comparisons, short-circuit guards, and operand evaluation order/count. +- Integer boundaries, promotions, narrowing, and defined arithmetic errors. +- Floating-point boundaries, signed zero, NaNs, infinities, and profile-specific + tolerances for mathematical functions. +- Signature ordering, captured constants, name collisions, and empty buffers. +- Invalid syntax, missing returns/bindings, unsupported types and capabilities. +- Malformed JSON, duplicate fields, invalid scalar encodings, unknown versions, + and inconsistent semantic declarations. +- Compiler pragma precedence, no-pragma defaults, and interpreter fallback. +- Frozen artifact import without its originating Python module. + +Use expected values derived from the specification, not only agreement between +two implementations. For single-evaluation tests, use native test instrumentation +where pure numeric outputs cannot reveal repeated evaluation; do not require +portable user callbacks just to make the tests observable. + +Run all core cases explicitly through the interpreter. Run the applicable corpus +through TCC, and through CC where available. JIT tests must inspect the actual +backend or use an existing no-fallback test mode so an interpreter fallback cannot +masquerade as JIT conformance. Fallback itself has separate tests. + +Include at least one configuration with TCC disabled and one normal bundled-TCC +configuration. Exercise representative supported platforms in CI as available. +JavaScript is a later capability-specific target, not a first-version gate. + +Python, build, and test commands in this repository must use the `blosc2` conda +environment. Run focused native tests and Python DSL tests as each layer changes, +then the repository's required checks before completion. Keep unrelated tests and +benchmarks outside the implementation loop unless failures justify investigation. + +## 10. Ordered work packages and completion gates + +### P0 — Audit and freeze a small contract + +- Locate authoritative miniexpr sources and dependency integration points. +- Record the reviewed miniexpr revision and use its existing canonical reference, + usage guide, and native DSL tests as the specification/conformance baseline. +- Inventory native parsing, dtype rules, execution APIs, capture specialization, + scalar bindings, and backend selection. +- Write the initial normative grammar/semantics and supported operation matrix. +- Record exclusions and resolve interpreter/JIT discrepancies for admitted cases. + +**Gate:** a precise candidate profile and first fixtures, with no dependence on +Python behavior to explain native semantics. + +### P1 — Execute identical raw source in C and Python + +- Add the standalone C runner and Python raw-source integration. +- Execute the affine example and control-flow cases with explicit signatures. +- Add interpreter/TCC backend observability and selection-policy tests. + +**Gate:** the same source executes without Python preparation in C and through +Python, and interpreter execution is verified explicitly. + +### P2 — Establish the shared core conformance suite + +- Expand fixtures across the frozen core syntax and dtype matrix. +- Document numerical comparison rules and runtime error categories. +- Verify interpreter/TCC parity and applicable CC coverage. + +**Gate:** all claimed v0.1 core semantics have representative positive, boundary, +and rejection coverage. The portable-source milestone is independently usable. + +### P3 — Implement the minimal artifact and C loader + +- Freeze the initial manifest and scalar encodings. +- Implement native decoding, binding validation, ownership, and error handling. +- Load a hand-authored artifact and reuse the P1 execution path. + +**Gate:** a standalone C executable loads and runs a fixture artifact without +Python and rejects malformed or unsupported artifacts explicitly. + +### P4 — Export and re-import a Python-authored kernel + +- Implement explicit-signature export and captured scalar parameterization. +- Implement Python import through the native portable-source path. +- Export in Python, execute in C, and compare against specified expected results. +- Verify snapshot semantics, deterministic export, and independence from the + original Python module. + +**Gate:** the complete Python-to-C artifact round trip works for the numeric core. + +### P5 — Document, stabilize, and review the first version + +- Publish the native reference and short Python/C examples. +- Document pragma precedence, fallback, version handling, and supported dtypes. +- Preserve frozen artifacts and complete focused regression/platform checks. +- Record practical limitations and review the next priorities with the user. + +**Gate:** v0.1 meets the checklist below. Further expansion is a separate decision. + +## 11. Follow-up candidates after v0.1 + +Extend the same corpus and manifest rather than redesigning the architecture. + +1. **Strings and bytes:** define encodings, lengths, case behavior, substring rules, + output storage, and dtype descriptions before claiming portable-profile support. + Start from existing `doc/strings.md` and `doc/dsl-syntax.md`: native string + locals and returns already work, widths have documented constraints, shorter + returns are NUL-padded, and string kernels execute on the interpreter rather + than the JIT. A string profile must not require TCC support to be portable. +2. **Native string methods:** consider a fixed whitelist lowering to existing + functions, without general object dispatch. +3. **Native membership:** consider `in`/`not in` for explicitly supported + string/bytes operands, with defined evaluation order. +4. **Frontend adapters:** NumPy aliases and pandas row access remain authoring and + binding conveniences; add portable column mappings when needed. +5. **Split unpacking:** decide missing-separator, empty-separator, result-count, + and evaluation-count semantics before lowering to `split_part` calls. Two + extraction calls do not automatically reproduce Python unpacking behavior. +6. **Additional execution profiles:** reductions, index-aware kernels, other + backends, and foreign-language bindings, each with matching conformance cases. + +Promotion of useful syntax into miniexpr is welcome when it benefits authors in +multiple environments. Eliminating a Python rewrite alone is not a sufficient +reason to enlarge the language. + +## 12. First-version acceptance checklist + +- [ ] Native versioned specification defines the admitted language subset. +- [ ] Same raw source and signature execute from C and Python. +- [ ] Interpreter passes the full core conformance corpus. +- [ ] Supported JIT paths pass applicable cases with actual backend verification. +- [ ] Compiler pragmas survive export and override local compiler defaults. +- [ ] Best-effort fallback preserves required semantics and remains quiet by default. +- [ ] Explicit typed constants survive a Python export/C import round trip. +- [ ] Saved artifacts execute without the original Python module or Python runtime. +- [ ] Loaders reject unsupported versions/capabilities and malformed bindings. +- [ ] Dtype, numeric, error, and buffer contracts are documented and tested. +- [ ] Existing Python authoring and evaluation APIs retain their behavior. +- [ ] Frozen artifacts and shared fixtures guard the published v0.1 contract. +- [ ] Follow-up scope is reviewed after this slice is working, not assumed upfront. diff --git a/plans/remove-numexpr-cc-results.json b/plans/remove-numexpr-cc-results.json new file mode 100644 index 000000000..1ae79de94 --- /dev/null +++ b/plans/remove-numexpr-cc-results.json @@ -0,0 +1,631 @@ +{ + "versions": { + "numpy": "2.5.4", + "numexpr": "2.14.2", + "blosc2": "4.15.0.dev0" + }, + "configuration": { + "items": [ + 1000, + 100000, + 8000000 + ], + "shape": null, + "input_order": "C", + "order": "K", + "dtype": "float64", + "cases": [ + "copy", + "linear", + "polynomial", + "sqrt", + "trig", + "complex" + ], + "threads": 8, + "samples": 7, + "warmups": 3, + "jit": "cc", + "backend": "jit", + "json": "plans/remove-numexpr-cc-results.json", + "native_revision": "ed437bd7b84f0e90e967664504e5d031169f4fb2" + }, + "platform": "macOS-26.6.2-arm64-arm-64bit-Mach-O", + "python": "3.14.4 | packaged by conda-forge | (main, Apr 8 2026, 02:33:53) [Clang 20.1.8 ]", + "native_probe_has_jit": true, + "package": "/Users/faltet/blosc/python-blosc2/build-windows-complex/wheel-test-package/blosc2/__init__.py", + "extension_sha256": "171adfe1755aae4a3b00ccfc1e0fd5e7d9f34338f7295d871ef005a8e5ea3953", + "numpy_temporaries": "Chained recipes allocate intermediates; copy and complex write directly to out.", + "results": [ + { + "case": "copy", + "expression": "copy(x)", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.0009573996067047119, + "blosc2": 0.0888332724571228, + "numexpr": 0.008624978363513947, + "numexpr_error": null, + "ratio": 10.29953568729079, + "route": "native-copy", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.0009164214134216309, + "blosc2": 0.011790543794631958, + "numexpr": 0.0029578804969787598 + } + }, + { + "case": "linear", + "expression": "x + y * 2 - 1", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.011582858860492706, + "blosc2": 0.0950004905462265, + "numexpr": 0.009874813258647919, + "numexpr_error": null, + "ratio": 9.620484768461756, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.0020833685994148254, + "blosc2": 0.006126239895820618, + "numexpr": 0.003334134817123413 + } + }, + { + "case": "polynomial", + "expression": "x * x + y * y + x * y", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.06479118019342422, + "blosc2": 0.41129253804683685, + "numexpr": 0.03570877015590668, + "numexpr_error": null, + "ratio": 11.517969850294715, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.03929156810045242, + "blosc2": 0.6296262145042419, + "numexpr": 0.03179255872964859 + } + }, + { + "case": "sqrt", + "expression": "sqrt(x * x + y * y)", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.1104576513171196, + "blosc2": 0.5074590444564819, + "numexpr": 0.053250230848789215, + "numexpr_error": null, + "ratio": 9.529706000664603, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.20483415573835373, + "blosc2": 0.31458400189876556, + "numexpr": 0.04270952194929123 + } + }, + { + "case": "trig", + "expression": "sin(x) + cos(y)", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.08224975317716599, + "blosc2": 0.437125563621521, + "numexpr": 0.05954131484031677, + "numexpr_error": null, + "ratio": 7.341550397297128, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.045083463191986084, + "blosc2": 0.08329097181558609, + "numexpr": 0.019834376871585846 + } + }, + { + "case": "complex", + "expression": "complex(x, y)", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.03716722130775452, + "blosc2": 0.1262091100215912, + "numexpr": 0.02275034785270691, + "numexpr_error": null, + "ratio": 5.547568364172261, + "route": "numpy/eager", + "execution_reports": [], + "output_bytes": 16000, + "spread_ms": { + "numpy": 0.04145968705415726, + "blosc2": 0.11191517114639282, + "numexpr": 0.008249655365943909 + } + }, + { + "case": "copy", + "expression": "copy(x)", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.02466607838869095, + "blosc2": 0.250999815762043, + "numexpr": 0.16945786774158478, + "numexpr_error": null, + "ratio": 1.481193048792552, + "route": "native-copy", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.007124617695808411, + "blosc2": 0.19845739006996155, + "numexpr": 0.043917447328567505 + } + }, + { + "case": "linear", + "expression": "x + y * 2 - 1", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.12375041842460632, + "blosc2": 0.2237502485513687, + "numexpr": 0.1622503623366356, + "numexpr_error": null, + "ratio": 1.3790431363545046, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.10870769619941711, + "blosc2": 0.04724971950054169, + "numexpr": 0.04654191434383392 + } + }, + { + "case": "polynomial", + "expression": "x * x + y * y + x * y", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.1775827258825302, + "blosc2": 0.20733289420604706, + "numexpr": 0.1454576849937439, + "numexpr_error": null, + "ratio": 1.4253828817292424, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.17395894974470139, + "blosc2": 0.06779097020626068, + "numexpr": 0.09554252028465271 + } + }, + { + "case": "sqrt", + "expression": "sqrt(x * x + y * y)", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.14066696166992188, + "blosc2": 0.24187471717596054, + "numexpr": 0.13833306729793549, + "numexpr_error": null, + "ratio": 1.7484952940067593, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.059874728322029114, + "blosc2": 0.022749416530132294, + "numexpr": 0.0404994934797287 + } + }, + { + "case": "trig", + "expression": "sin(x) + cos(y)", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.48458296805620193, + "blosc2": 0.29299966990947723, + "numexpr": 0.1265835016965866, + "numexpr_error": null, + "ratio": 2.314675024647214, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 4, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 4, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.16679149121046066, + "blosc2": 0.1100422814488411, + "numexpr": 0.1027919352054596 + } + }, + { + "case": "complex", + "expression": "complex(x, y)", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.073249451816082, + "blosc2": 0.1122504472732544, + "numexpr": 0.10470952838659286, + "numexpr_error": null, + "ratio": 1.0720175040691624, + "route": "numpy/eager", + "execution_reports": [], + "output_bytes": 1600000, + "spread_ms": { + "numpy": 0.01629069447517395, + "blosc2": 0.0255415216088295, + "numexpr": 0.07591582834720612 + } + }, + { + "case": "copy", + "expression": "copy(x)", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.9077917784452438, + "blosc2": 0.7462920621037483, + "numexpr": 0.7990002632141113, + "numexpr_error": null, + "ratio": 0.9340323107049608, + "route": "native-copy", + "execution_reports": [ + { + "intermediate_bytes": 0, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 0.07045920938253403, + "blosc2": 0.15016738325357437, + "numexpr": 0.07520802319049835 + } + }, + { + "case": "linear", + "expression": "x + y * 2 - 1", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 7.587040774524212, + "blosc2": 1.2304168194532394, + "numexpr": 1.2250831350684166, + "numexpr_error": null, + "ratio": 1.004353732601604, + "route": "native-jit", + "execution_reports": [ + { + "intermediate_bytes": 0, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 0.992998480796814, + "blosc2": 0.11637620627880096, + "numexpr": 0.07616635411977768 + } + }, + { + "case": "polynomial", + "expression": "x * x + y * y + x * y", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 17.60424952954054, + "blosc2": 1.1860411614179611, + "numexpr": 1.5959171578288078, + "numexpr_error": null, + "ratio": 0.7431721349694183, + "route": "native-jit", + "execution_reports": [ + { + "intermediate_bytes": 0, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 1.4864187687635422, + "blosc2": 0.11224951595067978, + "numexpr": 0.0721663236618042 + } + }, + { + "case": "sqrt", + "expression": "sqrt(x * x + y * y)", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 15.166041441261768, + "blosc2": 1.1713746935129166, + "numexpr": 1.4831246808171272, + "numexpr_error": null, + "ratio": 0.7898019017979985, + "route": "native-jit", + "execution_reports": [ + { + "intermediate_bytes": 0, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 1.8458757549524307, + "blosc2": 0.28629135340452194, + "numexpr": 0.0954996794462204 + } + }, + { + "case": "trig", + "expression": "sin(x) + cos(y)", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 36.911374889314175, + "blosc2": 4.220957867801189, + "numexpr": 3.873583860695362, + "numexpr_error": null, + "ratio": 1.0896776782427704, + "route": "native-jit", + "execution_reports": [ + { + "intermediate_bytes": 0, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 0.71741733700037, + "blosc2": 0.057499855756759644, + "numexpr": 0.05950126796960831 + } + }, + { + "case": "complex", + "expression": "complex(x, y)", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 4.4723330065608025, + "blosc2": 4.499875009059906, + "numexpr": 1.4244578778743744, + "numexpr_error": null, + "ratio": 3.159008826413861, + "route": "numpy/eager", + "execution_reports": [], + "output_bytes": 128000000, + "spread_ms": { + "numpy": 0.20604208111763, + "blosc2": 0.14616642147302628, + "numexpr": 0.3608325496315956 + } + } + ] +} diff --git a/plans/remove-numexpr-interpreter-results.json b/plans/remove-numexpr-interpreter-results.json new file mode 100644 index 000000000..c415820ae --- /dev/null +++ b/plans/remove-numexpr-interpreter-results.json @@ -0,0 +1,686 @@ +{ + "versions": { + "numpy": "2.5.4", + "numexpr": "2.14.2", + "blosc2": "4.15.0.dev0" + }, + "configuration": { + "items": [ + 1000, + 100000, + 8000000 + ], + "shape": null, + "input_order": "C", + "order": "K", + "dtype": "float64", + "cases": [ + "copy", + "linear", + "polynomial", + "sqrt", + "trig", + "complex" + ], + "threads": 8, + "samples": 7, + "warmups": 3, + "jit": "tcc", + "backend": "interpreter", + "json": "plans/remove-numexpr-interpreter-results.json", + "native_revision": "ed437bd7b84f0e90e967664504e5d031169f4fb2" + }, + "platform": "macOS-26.6.2-arm64-arm-64bit-Mach-O", + "python": "3.14.4 | packaged by conda-forge | (main, Apr 8 2026, 02:33:53) [Clang 20.1.8 ]", + "native_probe_has_jit": false, + "package": "/Users/faltet/blosc/python-blosc2/build-windows-complex/wheel-test-package/blosc2/__init__.py", + "extension_sha256": "171adfe1755aae4a3b00ccfc1e0fd5e7d9f34338f7295d871ef005a8e5ea3953", + "numpy_temporaries": "Chained recipes allocate intermediates; copy and complex write directly to out.", + "results": [ + { + "case": "copy", + "expression": "copy(x)", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.0008745118975639343, + "blosc2": 0.07575005292892456, + "numexpr": 0.007916241884231567, + "numexpr_error": null, + "ratio": 9.568941176470588, + "route": "native-copy", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.0007487833499908447, + "blosc2": 0.005999580025672913, + "numexpr": 0.002625398337841034 + } + }, + { + "case": "linear", + "expression": "x + y * 2 - 1", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.01020822674036026, + "blosc2": 0.07970817387104034, + "numexpr": 0.008666887879371643, + "numexpr_error": null, + "ratio": 9.196862239415431, + "route": "native-interpreter", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.0015832483768463135, + "blosc2": 0.00608246773481369, + "numexpr": 0.002834014594554901 + } + }, + { + "case": "polynomial", + "expression": "x * x + y * y + x * y", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.010667368769645691, + "blosc2": 0.08587539196014404, + "numexpr": 0.00858306884765625, + "numexpr_error": null, + "ratio": 10.005208333333334, + "route": "native-interpreter", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.0020423904061317444, + "blosc2": 0.005624257028102875, + "numexpr": 0.0021243467926979065 + } + }, + { + "case": "sqrt", + "expression": "sqrt(x * x + y * y)", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.010749325156211853, + "blosc2": 0.08437503129243851, + "numexpr": 0.009084120392799377, + "numexpr_error": null, + "ratio": 9.288189460734058, + "route": "native-interpreter", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.0010849907994270325, + "blosc2": 0.007166527211666107, + "numexpr": 0.0023329630494117737 + } + }, + { + "case": "trig", + "expression": "sin(x) + cos(y)", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.01345854252576828, + "blosc2": 0.08437503129243851, + "numexpr": 0.01037493348121643, + "numexpr_error": null, + "ratio": 8.132585278276482, + "route": "native-interpreter", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.0014593824744224548, + "blosc2": 0.0023348256945610046, + "numexpr": 0.001584179699420929 + } + }, + { + "case": "complex", + "expression": "complex(x, y)", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.010250136256217957, + "blosc2": 0.04062522202730179, + "numexpr": 0.007917173206806183, + "numexpr_error": null, + "ratio": 5.131278673097283, + "route": "numpy/eager", + "execution_reports": [], + "output_bytes": 16000, + "spread_ms": { + "numpy": 0.004625879228115082, + "blosc2": 0.003957189619541168, + "numexpr": 0.002166256308555603 + } + }, + { + "case": "copy", + "expression": "copy(x)", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.009624287486076355, + "blosc2": 0.09616557508707047, + "numexpr": 0.08745864033699036, + "numexpr_error": null, + "ratio": 1.099554883503003, + "route": "native-copy", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.005626119673252106, + "blosc2": 0.03066565841436386, + "numexpr": 0.024416483938694 + } + }, + { + "case": "linear", + "expression": "x + y * 2 - 1", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.06700027734041214, + "blosc2": 0.18016714602708817, + "numexpr": 0.10237470269203186, + "numexpr_error": null, + "ratio": 1.7598795531458098, + "route": "native-interpreter", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.04779081791639328, + "blosc2": 0.027750618755817413, + "numexpr": 0.02100132405757904 + } + }, + { + "case": "polynomial", + "expression": "x * x + y * y + x * y", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.09595789015293121, + "blosc2": 0.16862433403730392, + "numexpr": 0.12233294546604156, + "numexpr_error": null, + "ratio": 1.3784049210530323, + "route": "native-interpreter", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.06470922380685806, + "blosc2": 0.03925152122974396, + "numexpr": 0.09070988744497299 + } + }, + { + "case": "sqrt", + "expression": "sqrt(x * x + y * y)", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.09162444621324539, + "blosc2": 0.1955004408955574, + "numexpr": 0.11891685426235199, + "numexpr_error": null, + "ratio": 1.6440095233619973, + "route": "native-interpreter", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.05050096660852432, + "blosc2": 0.022124499082565308, + "numexpr": 0.056624412536621094 + } + }, + { + "case": "trig", + "expression": "sin(x) + cos(y)", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.4275413230061531, + "blosc2": 0.24404190480709076, + "numexpr": 0.12587476521730423, + "numexpr_error": null, + "ratio": 1.9387675074172999, + "route": "native-interpreter", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 4, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 4, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.16199983656406403, + "blosc2": 0.059291720390319824, + "numexpr": 0.04091765731573105 + } + }, + { + "case": "complex", + "expression": "complex(x, y)", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.07079169154167175, + "blosc2": 0.09125005453824997, + "numexpr": 0.09954161942005157, + "numexpr_error": null, + "ratio": 0.9167025317640014, + "route": "numpy/eager", + "execution_reports": [], + "output_bytes": 1600000, + "spread_ms": { + "numpy": 0.020625069737434387, + "blosc2": 0.02512335777282715, + "numexpr": 0.037833116948604584 + } + }, + { + "case": "copy", + "expression": "copy(x)", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.9184163063764572, + "blosc2": 0.6670001894235611, + "numexpr": 0.8027497678995132, + "numexpr_error": null, + "ratio": 0.8308942787599223, + "route": "native-copy", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 8, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 8, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 0.07899943739175797, + "blosc2": 0.1067090779542923, + "numexpr": 0.04904158413410187 + } + }, + { + "case": "linear", + "expression": "x + y * 2 - 1", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 7.367374375462532, + "blosc2": 1.4739595353603363, + "numexpr": 1.2202495709061623, + "numexpr_error": null, + "ratio": 1.2079164545542662, + "route": "native-interpreter", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 8, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 8, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 0.8333344012498856, + "blosc2": 0.581999309360981, + "numexpr": 0.08462462574243546 + } + }, + { + "case": "polynomial", + "expression": "x * x + y * y + x * y", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 17.396249808371067, + "blosc2": 1.369374804198742, + "numexpr": 1.607040874660015, + "numexpr_error": null, + "ratio": 0.8521095049859552, + "route": "native-interpreter", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 8, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 8, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 1.983831636607647, + "blosc2": 0.16345828771591187, + "numexpr": 0.08245836943387985 + } + }, + { + "case": "sqrt", + "expression": "sqrt(x * x + y * y)", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 15.408750623464584, + "blosc2": 1.5693753957748413, + "numexpr": 1.5039583668112755, + "numexpr_error": null, + "ratio": 1.0434965690587994, + "route": "native-interpreter", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 8, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 8, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 1.148708164691925, + "blosc2": 0.3820406273007393, + "numexpr": 0.10833423584699631 + } + }, + { + "case": "trig", + "expression": "sin(x) + cos(y)", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 36.627791821956635, + "blosc2": 4.441250115633011, + "numexpr": 3.854040987789631, + "numexpr_error": null, + "ratio": 1.1523619312051365, + "route": "native-interpreter", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 8, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 8, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 0.5418341606855392, + "blosc2": 0.13354234397411346, + "numexpr": 0.06408337503671646 + } + }, + { + "case": "complex", + "expression": "complex(x, y)", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 4.5212917029857635, + "blosc2": 4.563332535326481, + "numexpr": 1.4377925544977188, + "numexpr_error": null, + "ratio": 3.1738462694436778, + "route": "numpy/eager", + "execution_reports": [], + "output_bytes": 128000000, + "spread_ms": { + "numpy": 0.15133339911699295, + "blosc2": 0.25724805891513824, + "numexpr": 0.44583436101675034 + } + } + ] +} diff --git a/plans/remove-numexpr-jit-results.json b/plans/remove-numexpr-jit-results.json new file mode 100644 index 000000000..95d99826b --- /dev/null +++ b/plans/remove-numexpr-jit-results.json @@ -0,0 +1,631 @@ +{ + "versions": { + "numpy": "2.5.4", + "numexpr": "2.14.2", + "blosc2": "4.15.0.dev0" + }, + "configuration": { + "items": [ + 1000, + 100000, + 8000000 + ], + "shape": null, + "input_order": "C", + "order": "K", + "dtype": "float64", + "cases": [ + "copy", + "linear", + "polynomial", + "sqrt", + "trig", + "complex" + ], + "threads": 8, + "samples": 7, + "warmups": 3, + "jit": "tcc", + "backend": "jit", + "json": "plans/remove-numexpr-jit-results.json", + "native_revision": "ed437bd7b84f0e90e967664504e5d031169f4fb2" + }, + "platform": "macOS-26.6.2-arm64-arm-64bit-Mach-O", + "python": "3.14.4 | packaged by conda-forge | (main, Apr 8 2026, 02:33:53) [Clang 20.1.8 ]", + "native_probe_has_jit": true, + "package": "/Users/faltet/blosc/python-blosc2/build-windows-complex/wheel-test-package/blosc2/__init__.py", + "extension_sha256": "171adfe1755aae4a3b00ccfc1e0fd5e7d9f34338f7295d871ef005a8e5ea3953", + "numpy_temporaries": "Chained recipes allocate intermediates; copy and complex write directly to out.", + "results": [ + { + "case": "copy", + "expression": "copy(x)", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.0008745118975639343, + "blosc2": 0.0811675563454628, + "numexpr": 0.007541850209236145, + "numexpr_error": null, + "ratio": 10.762286984440603, + "route": "native-copy", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.0009592622518539429, + "blosc2": 0.012042000889778137, + "numexpr": 0.0034999102354049683 + } + }, + { + "case": "linear", + "expression": "x + y * 2 - 1", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.010540708899497986, + "blosc2": 0.085415318608284, + "numexpr": 0.008584000170230865, + "numexpr_error": null, + "ratio": 9.95052620158403, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.0033741816878318787, + "blosc2": 0.015042722225189209, + "numexpr": 0.004999339580535889 + } + }, + { + "case": "polynomial", + "expression": "x * x + y * y + x * y", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.010917894542217255, + "blosc2": 0.08954200893640518, + "numexpr": 0.009042210876941681, + "numexpr_error": null, + "ratio": 9.902667627974045, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.0026244670152664185, + "blosc2": 0.01479126513004303, + "numexpr": 0.0024158507585525513 + } + }, + { + "case": "sqrt", + "expression": "sqrt(x * x + y * y)", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.010999850928783417, + "blosc2": 0.09129196405410767, + "numexpr": 0.009207986295223236, + "numexpr_error": null, + "ratio": 9.914433093961769, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.0012908130884170532, + "blosc2": 0.019750557839870453, + "numexpr": 0.0023758038878440857 + } + }, + { + "case": "trig", + "expression": "sin(x) + cos(y)", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.013832934200763702, + "blosc2": 0.08854269981384277, + "numexpr": 0.011000782251358032, + "numexpr_error": null, + "ratio": 8.048763968845241, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 8000, + "spread_ms": { + "numpy": 0.002666376531124115, + "blosc2": 0.015042722225189209, + "numexpr": 0.003082677721977234 + } + }, + { + "case": "complex", + "expression": "complex(x, y)", + "items": 1000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.00958424061536789, + "blosc2": 0.03841612488031387, + "numexpr": 0.007624737918376923, + "numexpr_error": null, + "ratio": 5.038353487235861, + "route": "numpy/eager", + "execution_reports": [], + "output_bytes": 16000, + "spread_ms": { + "numpy": 0.0018775463104248047, + "blosc2": 0.0033760443329811096, + "numexpr": 0.002668239176273346 + } + }, + { + "case": "copy", + "expression": "copy(x)", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.010167248547077179, + "blosc2": 0.09450037032365799, + "numexpr": 0.09208265691995621, + "numexpr_error": null, + "ratio": 1.026255904038514, + "route": "native-copy", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 0, + "interpreter_stages": 1 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 0, + "interpreter_stages": 1 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.004707835614681244, + "blosc2": 0.05254242569208145, + "numexpr": 0.03004167228937149 + } + }, + { + "case": "linear", + "expression": "x + y * 2 - 1", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.06675068289041519, + "blosc2": 0.3186250105500221, + "numexpr": 0.10974984616041183, + "numexpr_error": null, + "ratio": 2.9031932316726494, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.06720889359712601, + "blosc2": 0.1609157770872116, + "numexpr": 0.026124529540538788 + } + }, + { + "case": "polynomial", + "expression": "x * x + y * y + x * y", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.11216755956411362, + "blosc2": 0.16083382070064545, + "numexpr": 0.1032920554280281, + "numexpr_error": null, + "ratio": 1.5570783254740372, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.13966672122478485, + "blosc2": 0.09450037032365799, + "numexpr": 0.02954155206680298 + } + }, + { + "case": "sqrt", + "expression": "sqrt(x * x + y * y)", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.09279139339923859, + "blosc2": 0.35845767706632614, + "numexpr": 0.09958352893590927, + "numexpr_error": null, + "ratio": 3.5995679295220104, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 1, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.03254227340221405, + "blosc2": 0.07724948227405548, + "numexpr": 0.05995761603116989 + } + }, + { + "case": "trig", + "expression": "sin(x) + cos(y)", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.41737500578165054, + "blosc2": 0.28187502175569534, + "numexpr": 0.13466738164424896, + "numexpr_error": null, + "ratio": 2.093120236794423, + "route": "native-jit", + "execution_reports": [ + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 4, + "jit_stages": 1, + "interpreter_stages": 0 + }, + { + "temporary_bytes": 0, + "gathered_bytes": 0, + "intermediate_bytes": 0, + "tasks": 4, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 800000, + "spread_ms": { + "numpy": 0.06687454879283905, + "blosc2": 0.08520763367414474, + "numexpr": 0.0589592382311821 + } + }, + { + "case": "complex", + "expression": "complex(x, y)", + "items": 100000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.07124990224838257, + "blosc2": 0.09445752948522568, + "numexpr": 0.10979175567626953, + "numexpr_error": null, + "ratio": 0.8603335369163952, + "route": "numpy/eager", + "execution_reports": [], + "output_bytes": 1600000, + "spread_ms": { + "numpy": 0.02120714634656906, + "blosc2": 0.02587493509054184, + "numexpr": 0.02583395689725876 + } + }, + { + "case": "copy", + "expression": "copy(x)", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 0.9217076003551483, + "blosc2": 0.7571252062916756, + "numexpr": 0.7987087592482567, + "numexpr_error": null, + "ratio": 0.9479365257046642, + "route": "native-copy", + "execution_reports": [ + { + "intermediate_bytes": 0, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 0.08687563240528107, + "blosc2": 0.20012445747852325, + "numexpr": 0.059874728322029114 + } + }, + { + "case": "linear", + "expression": "x + y * 2 - 1", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 8.259916678071022, + "blosc2": 1.4142915606498718, + "numexpr": 1.2415843084454536, + "numexpr_error": null, + "ratio": 1.139102315509012, + "route": "native-jit", + "execution_reports": [ + { + "intermediate_bytes": 0, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 1.0845419019460678, + "blosc2": 0.11566653847694397, + "numexpr": 0.08020736277103424 + } + }, + { + "case": "polynomial", + "expression": "x * x + y * y + x * y", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 19.462457858026028, + "blosc2": 1.6041658818721771, + "numexpr": 1.691250130534172, + "numexpr_error": null, + "ratio": 0.9485089478547506, + "route": "native-jit", + "execution_reports": [ + { + "intermediate_bytes": 0, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 0.681709498167038, + "blosc2": 0.08237455040216446, + "numexpr": 0.2115834504365921 + } + }, + { + "case": "sqrt", + "expression": "sqrt(x * x + y * y)", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 15.444749966263771, + "blosc2": 3.364499658346176, + "numexpr": 1.496042124927044, + "numexpr_error": null, + "ratio": 2.2489337715074362, + "route": "native-jit", + "execution_reports": [ + { + "intermediate_bytes": 0, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 0.7914174348115921, + "blosc2": 0.11612474918365479, + "numexpr": 0.09024981409311295 + } + }, + { + "case": "trig", + "expression": "sin(x) + cos(y)", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 37.36520744860172, + "blosc2": 5.6580835953354836, + "numexpr": 3.8838330656290054, + "numexpr_error": null, + "ratio": 1.4568297606321372, + "route": "native-jit", + "execution_reports": [ + { + "intermediate_bytes": 0, + "output_copy_bytes": 0, + "input_materialization_bytes": 0, + "jit_stages": 1, + "interpreter_stages": 0 + } + ], + "output_bytes": 64000000, + "spread_ms": { + "numpy": 1.8984172493219376, + "blosc2": 0.1005418598651886, + "numexpr": 0.06758235394954681 + } + }, + { + "case": "complex", + "expression": "complex(x, y)", + "items": 8000000, + "dtype": "float64", + "status": "qualified", + "numpy": 4.495291970670223, + "blosc2": 4.63058240711689, + "numexpr": 1.438625156879425, + "numexpr_error": null, + "ratio": 3.2187553408013923, + "route": "numpy/eager", + "execution_reports": [], + "output_bytes": 128000000, + "spread_ms": { + "numpy": 0.20299945026636124, + "blosc2": 0.3067096695303917, + "numexpr": 0.36587659269571304 + } + } + ] +} diff --git a/plans/remove-numexpr-status.md b/plans/remove-numexpr-status.md new file mode 100644 index 000000000..28d20d76c --- /dev/null +++ b/plans/remove-numexpr-status.md @@ -0,0 +1,166 @@ +# NumExpr removal: completion audit + +Date: 2026-10-22. Baseline: Python-Blosc2 `77e21443`, miniexpr +`ed437bd7b84f0e90e967664504e5d031169f4fb2`. This document describes the follow-up +working-tree changes as well; it is not evidence of remote qualification of them. + +## Runtime inventory and ownership + +The original runtime removal already existed before this audit. A source/metadata +audit found no package import or executable call to the NumExpr package. Historical +release notes and external comparison tools are not runtime integrations. + +| Location | Replacement / retained contract | Owning checks | +| --- | --- | --- | +| `pyproject.toml` | No required NumExpr dependency | Wheel metadata audit; `qualify_without_numexpr.py` | +| `__init__.py`, `core.py` | No optional import, initialization, thread coupling or version probe; `numexpr=None` is compatibility only | `test_no_numexpr.py`, `test_expression_threads.py` | +| `lazyexpr.evaluate_chunk` | Metadata-only native graph admission; otherwise explicit NumPy semantics | `test_no_numexpr.py`, `test_evaluate_numpy_compat.py` | +| `lazyexpr.ne_evaluate` | Non-executing legacy name delegating to `evaluate_chunk`; preserves caller depth | Caller-scope checks in `test_no_numexpr.py` | +| Chunk maps, filters, reductions | Existing native prefilters or tile-local NumPy execution; no execution-error replay | `test_evaluate_numpy_prefilter.py`, ndarray reduction/selection tests | +| Resident program cache | Removed; bounded native preparation caches contain no operand arrays | `test_prepared_evaluate.py`, `test_re_evaluate.py`, native graph tests | +| `_numpy_eval_expr`, scalar construction | Native metadata or approved NumPy probes; no NumExpr validation/inference | LazyExpr, expression-policy and dtype tests | +| `expression_graph.py`, `utils.py`, `ndarray.py` | Approved expression grammar, NumPy function registry and native numerical contracts | Safe/full evaluation tests; elementwise function tests | +| `ctable.py`, `indexing.py` | Shared expression helpers, no direct NumExpr calls | Existing table/index/query suites | +| Benchmark/reference tests | Optional external NumExpr only; essential behavior does not skip when it is absent | Full absence run; benchmark tests without NumExpr | + +The old minimum/maximum NaN assertion skips have been removed: those tests now +enforce the actual NumPy contract instead of hiding disagreements attributed to a +backend that is no longer used. Historical WASM/feature exclusions unrelated to +dependency removal have not been broadened or silently reclassified as native. + +## Compatibility and coverage decisions + +| Surface | Policy | +| --- | --- | +| `local_dict`, `global_dict`, caller lookup | Preserve public lookup and internal wrapper depth; do not cache frames | +| `out`, `casting`, `order` | Blosc2-owned shape/identity/layout/casting contracts, validated before writes | +| `optimization` | Validated compatibility hint; no NumExpr algebraic rewrites | +| `truediv` | Removed from `evaluate`/prepared evaluators; Python 3 / NumPy division, `//` for floor division | +| `sanitize` | Removed; mandatory safe-mode validation and the separate full-mode trust policy remain | +| `disable_cache` | Removed; operand-free preparation caches are automatic, diagnostic tooling owns cold-cache controls | +| `ne_args` | Legacy internal compatibility container; not a public `evaluate` option or engine selector | +| `blosc2.numexpr`, internal `lazyexpr.numexpr` | `None` placeholders, never a runtime import | +| `NUMEXPR_*` | No effect on Blosc2 workers or native execution policy | +| Automatic execution | Shared native structure classification: single-return expressions interpret, multi-statement programs prefer JIT; explicit policies and source compiler pragmas take priority | +| `jit=False` / unavailable compiler | Native interpretation where supported, not an unrelated expression engine | +| Strict native / require-JIT | Unsupported native signatures reject; explicitly required JIT still rejects when unavailable | +| Numerical/runtime errors | Propagate; preparation-only unsupported signatures may choose NumPy before execution | + +Admitted real numeric maps, selection and supported reductions use existing native +graphs/schedulers. Complex portable kernels and qualified expression paths use +native interpretation, including the newly batched arithmetic; unsupported +complex construction/functions keep explicit NumPy semantics. Strings and +datetime/timedelta operations use approved NumPy semantics when native admission +declines, preserving units, NaT and component-safe complex construction. Unsupported +linalg and shape-changing operations retain their materialization contracts. + +WASM's scalar string-expression reduction prefilter remains disabled for **all** +dtypes. Its chunked fallback is not a NumExpr dependency, and portable Menudet block +reductions remain supported. No host-worker speedup is claimed for WASM. + +## Gaps fixed in this audit + +- Native map and scalar-reduction prefilter exceptions after successful preparation + now propagate, with prefilter cleanup, rather than replaying through NumPy. + Injection tests preserve a partial caller-output write and prohibit replay. +- The existing serial bounded stored-output schedule no longer requires a JIT + artifact. Its 262,144-element tile limit, output identity, broadcasting and + interpreter route are tested; no new scheduler or parallel-safety rule is added. +- Direct `evaluate_chunk` caller lookup and fallback context now work independently + of the legacy helper name. +- Absence tests cover resident/compressed/mixed, layout, complex, strings, NaT, + prepared/repeated calls and genuine no-JIT execution. A hostile installed-module + stand-in rejects NumExpr backend/thread accesses. +- The qualification runner blocks NumExpr imports, records swallowed package import + attempts, checks requirements and optionally requires both module/distribution + absence. CI explicitly uninstalls the optional reference before its full suite. +- The resident benchmark always provides a NumPy reference. NumExpr is optional; + unavailable or non-equivalent reference results remain `N/A`, with reasons in + JSON rather than a verbose table trailer. Native route probes observe successful + execution/reporting, not merely an attempted lowering. +- Repeated resident native maps reuse bounded lowered plans keyed by metadata + only; arrays and outputs are rebound per call. Syntax admission is cached and + small maps bypass parallel-admission work. Warmed 1K `evaluate(out=...)` + improved from ~66/74 µs (copy/linear) to ~26/30 µs. The cache is operand-free, + thread-safe, size-bounded and invalidated by dtype/shape/mode/policy changes; + aliased or incompatible outputs retain the general validated path. + +## Qualification and release boundaries + +The published baseline already passed native Linux/macOS/Windows x64/ARM64/WASM +CI and Python Linux/macOS/Windows/WASM CI. That evidence predates this audit and +must not be presented as qualification of its new changes. + +Local qualification (macOS arm64, Python 3.14.4, NumPy 2.5.4, Python-Blosc2 +`77e21443` plus this audit, native `ed437bd7...`): + +- Shared-test-package full suite with NumExpr installed: **11,825 passed, + 145 skipped**. +- Independently built/extracted wheel with both NumExpr module and distribution + metadata absent: **11,825 passed, 145 skipped**, and zero recorded package + NumExpr import attempts. +- **85** packaged Python modules audited: no NumExpr import and no wheel + `Requires-Dist: numexpr`. +- The old thread test was replaced by an independence test: `NUMEXPR_*` + variables do not control Blosc2 workers and NumExpr remains unimported. +- Focused absence/replay/dispatch/benchmark suites passed, including the static + package import/metadata audit and optional-tool unavailability paths. +- Sphinx documentation builds with only pre-existing warnings. +- After the `evaluate()` interpretation-default/API cleanup, the full local suite + passed **11,828 tests, 145 skipped**. Focused cleanup coverage also passed with + NumExpr absent and zero recorded runtime imports. Pre-push cache review added + policy-invalidation, exact-type admission, eviction, strided-binding and + concurrent-rebinding tests; all **44** focused policy/cache/absence tests pass. +- These counts are local evidence only; the new CI gates and follow-up changes + have not yet run on remote platforms. + +The shared conda installation is never uninstalled or overwritten: a +dependency-only search path excludes both NumExpr's module and metadata, and an +independently built wheel supplies the tested native extension. + +### Refreshed performance + +M4 Pro, eight workers, shared warmed NumPy destination, resident float64 inputs, +median of seven shuffled samples after three warmups. NumExpr 2.14.2 is an +external reference. TCC and system-CC JIT use separate runs. Routes come from the +native execution report; `copy` may use the identity/copy path when eligible. +Chained NumPy recipes allocate intermediates, while copy/complex write directly +to `out`. + +| Recipe | NumPy ms | NumExpr ms | Interpreter ms | CC JIT ms | Route | +| --- | ---: | ---: | ---: | ---: | --- | +| copy | 0.918 | 0.803 | **0.667** | **0.746** | native identity/copy | +| linear | 7.367 | 1.220 | 1.474 | 1.230 | native | +| polynomial | 17.396 | 1.607 | 1.369 | 1.186 | native | +| sqrt norm | 15.409 | 1.504 | 1.569 | 1.171 | native | +| sine + cosine | 36.628 | 3.854 | 4.441 | 4.221 | native | +| complex(x, y) | 4.521 | 1.438 | 4.563 | 4.500 | NumPy fallback | + +The interpreter results contain `jit_stages=0` and `interpreter_stages=1`, +`temporary_bytes=0`, no full-input materialization and eight map tasks; the route +probe verifies actual execution, not merely a lowering attempt. At 100K elements +interpreter maps take 0.10–0.24 ms versus NumExpr 0.09–0.14 ms; at 1K elements +Blosc2 API/preparation overhead is now about 0.04–0.05 ms versus NumExpr +0.008–0.012 ms after the prepared-plan cache. + +Raw medians, spreads, routes and native execution reports: +[interpreter](remove-numexpr-interpreter-results.json), +[CC JIT](remove-numexpr-cc-results.json), +[TCC JIT](remove-numexpr-jit-results.json). Reproduce with: + +```sh +conda run -n blosc2 python bench/evaluate-numpy-parity.py \ + --items 1000 100000 8000000 --backend interpreter --threads 8 \ + --samples 7 --warmups 3 --cases copy linear polynomial sqrt trig complex +``` + +Performance is not an absence gate. Existing before-removal baselines and residual +no-JIT regressions remain in [miniexpr-implementation-results.md](miniexpr-implementation-results.md) +and [no-jit-and-small-math.md](no-jit-and-small-math.md). The latter supersedes the +earlier scalar-interpreter snapshots. Native complex arithmetic batching improves +native complex expression throughput, but the benchmark's complex constructor +remains an explicit NumPy fallback and is not universal NumExpr parity. + +Release approval, acceptable regression budgets, 100M/full mixed-layout memory +qualification, and remote CI for these follow-up changes remain explicit decision +points. They are not silently marked complete by a local functional pass. diff --git a/plans/remove-numexpr.md b/plans/remove-numexpr.md new file mode 100644 index 000000000..027c52610 --- /dev/null +++ b/plans/remove-numexpr.md @@ -0,0 +1,441 @@ +# Remove NumExpr from Python-Blosc2 + +Status: runtime removal implemented on `improved-miniexpr`; performance and +platform qualification remain release decision points. See +[miniexpr-implementation-results.md](miniexpr-implementation-results.md). + +Current completion audit, compatibility/coverage inventory and follow-up +qualification: [remove-numexpr-status.md](remove-numexpr-status.md). The earlier +starting-point descriptions and timing snapshots below are historical, not a +claim that the current package still imports NumExpr. + +### Implemented removal + +- Removed the runtime import, required dependency, NumExpr program cache, + initialization/thread coupling and version diagnostics. +- Internal chunk evaluation now selects native graph execution or approved + NumPy evaluation before execution; numerical failures are not replayed. +- Native interpreter admission no longer requires JIT. Native destination + descriptors and host task partitioning are integrated into Python-Blosc2. +- Complex construction can fill an existing NumPy complex destination directly; + unsupported operations retain explicit NumPy semantics rather than NumExpr. +- Compatibility keyword spellings remain validated, but `optimization` does not + reproduce NumExpr algebraic rewrites. Nullable `numexpr=None` attributes and + the legacy `ne_evaluate` helper name remain non-executing compatibility surfaces. +- Added an isolated subprocess that rejects NumExpr imports and qualifies + resident, compressed, complex, prepared and repeated evaluation. Full-suite + absence qualification is performed with a NumExpr import blocker as well. + +Functional independence is not universal performance parity: genuine no-JIT +arithmetic is substantially slower than the previous NumExpr fallback. Windows +and remote exact-revision evidence are also not yet qualified. These must remain +explicit when deciding whether to release the removal. + +### Allocation-policy prerequisite implemented + +This subsection records the earlier prerequisite. Native destination descriptors +now replace the resident NumPy layout fallback for admitted numerical graphs; +unsupported operations still have explicit NumPy fallbacks. + +`evaluate()` now consumes `order` as a Blosc2 allocation policy instead of +forwarding it in NumExpr options. Explicit `order="C"` therefore no longer blocks +native-first admission. `A`/`K` follow the allocated destination's actual layout; +an explicit destination retains its own layout regardless of `order`. + +For resident expressions with non-C-contiguous NumPy destinations, the fallback +evaluates the approved expression graph with NumPy and copies into the supplied +output. It does not select NumExpr because of layout. This supports Fortran and +strided outputs, but may allocate a full intermediate result and is not native +strided-output acceleration. Compressed/mixed inputs still need the bounded +fallback migration described below. NumExpr remains in other runtime paths. + +Tests block NumExpr entry points for representative layout cases and verify that +explicit C order retains native admission. Future interpreter/JIT strided sinks +should replace this NumPy fallback without changing the allocation contract. + +## 1. Goal and definition of completion + +Remove NumExpr completely from Python-Blosc2's runtime implementation and required +dependencies. Use miniexpr (Menudet interpreter and optional JIT) for admitted +numerical expressions, with explicit NumPy implementations for unsupported +operations. Preserve the expression API, bounded-memory execution and fused +evaluation/compression wherever their contracts permit. + +Completion means: + +- No package imports, calls, compilation, validation, dtype inference, thread + configuration or version reporting depend on NumExpr. +- Installation and the mandatory test suite work with NumExpr absent. Installing + NumExpr alongside Blosc2 does not change Blosc2's behavior or chosen backend. +- JIT-disabled and JIT-unavailable execution are supported first-class modes, + rather than reasons to choose an unrelated expression engine. +- Resident, compressed, mixed and explicit-output workloads retain their public + contracts. Any intentional compatibility changes are documented and reviewed. +- Optional comparison tools may import NumExpr **as an external reference only**. + They must not be imported by the package or required by normal tests/install. + +Removing the dependency does not require native complex/string implementation, +nor does it imply universal performance superiority over NumExpr. These are +separate objectives; remaining performance gaps must be measured and visible. + +## 2. Starting point and evidence + +See [evaluate-numpy-parity.md](evaluate-numpy-parity.md) and +[menudet-performance-parity.md](menudet-performance-parity.md). + +The current checkout already has native graph preparation, specialization, +interpreter execution, JIT execution, bounded storage readers, resident workers, +and shared compression-prefilter execution. Eligible real arithmetic, math, +selection and reductions use these paths. However, several automatic admissions +require a JIT artifact even when the native interpreter can evaluate the graph. + +The recent 72-case NumPy-output audit closed sampled API gaps; it is not an +exhaustive backend/dtype qualification. The direct-output NumExpr program cache +added during that work improves fallback performance but is explicitly temporary +in the architecture proposed here. + +Recent copy measurements on M4 Pro, float64, eight threads, warmed explicit +destination, median of 31 shuffled samples: + +| Elements | NumPy | NumExpr | Blosc2 JIT | Blosc2 with JIT disabled | +| --- | ---: | ---: | ---: | ---: | +| 8M | 0.922 ms | 0.801 ms | 0.762 ms | 0.902 ms | +| 100M | 11.917 ms | 10.143 ms | 7.020 ms | 10.277 ms | + +The JIT-disabled measurements are from a separate run and **used the NumExpr +compatibility backend**. They are not Menudet interpreter measurements. The +corresponding NumPy/NumExpr controls in that run were 0.951/0.803 ms and +11.889/10.151 ms. Establish a genuine interpreter baseline before predicting +whether it will be faster. + +Known performance gaps include small-array preparation/scheduling and conservative +parallel admission for integer-input math. Native complex support has not been +established by adding the expression-level `complex(real, imag)` constructor. + +## 3. Dependency and behavior inventory + +Start with a repository-wide search, including docs, examples, packaging, +benchmarks, CI scripts and tests. Classify every occurrence as runtime behavior, +public compatibility, test oracle, benchmark comparison or historical prose. +Record the replacement and owning test for each runtime call site. + +| Location | Current responsibility | Planned treatment | +| --- | --- | --- | +| `pyproject.toml` | Required host dependency | Remove after replacement paths qualify. | +| `src/blosc2/__init__.py` | Optional import, `blosc2.numexpr`, initialization of NumExpr threads | Remove runtime integration; decide exposed-attribute migration. | +| `src/blosc2/core.py` | Thread documentation and version diagnostics | Report Blosc2/native capabilities; remove NumExpr coupling. | +| `src/blosc2/lazyexpr.py:ne_evaluate` | Safe/full evaluation, operand discovery, NumExpr validation, datetime and NumPy fallbacks | Replace with backend-neutral dispatch preserving scope and evaluation policy. | +| `_resident_numexpr_program`, `_resident_numexpr_output` | Compiled compatibility cache and direct NumPy output | Replace with native direct-output execution or explicit NumPy fallback; delete program cache. | +| Lazy expression chunk/reduction/selection paths | Repeated `ne_evaluate` calls and fused expressions | Route through shared native preparation/execution, not a second scheduler. | +| `_numpy_eval_expr`, scalar expression construction | Metadata inference and eager scalar evaluation | Use native metadata or approved NumPy semantics without NumExpr. | +| `expression_graph.py`, `utils.py`, `ndarray.py` | Function registry, shape inference, ufunc dispatch and aliases | Audit semantics and remove backend-dependent assumptions/comments. | +| `ctable.py`, indexing and query consumers | Chunked predicates, strings, fields and layout assumptions | Verify shared expression behavior and bounded memory transitively. | +| `tests/test_numexpr_threads.py` and NumExpr-based tests | Thread integration and reference results | Replace integration assertions; separate optional reference tests. | + +Do not assume that replacing the public `evaluate()` path removes the dependency: +scalar construction, metadata probes and internal chunk calls are also consumers. + +## 4. Intended execution architecture + +```text +public expression / LazyExpr / internal chunk evaluation + -> existing evaluation-policy and operand validation + -> normalized expression + dtype/shape/output contract + -> immutable native preparation when supported + -> JIT implementation when enabled and available + -> Menudet interpreter otherwise + -> explicit NumPy fallback when native preparation declares unsupported + -> shared scheduling and destination handling +``` + +### Admission and failure rules + +- Separate semantic capability, backend availability and parallel-safety proofs. + `has_jit == False` alone must not mean “unsupported expression.” +- Keep strict-native requests strict. An interpreter is native execution; NumPy + is not. An explicit require-JIT request must fail if JIT is unavailable. +- Fallback is a preparation decision. A kernel execution error must propagate; + never replay a partially written operation using another backend. +- Keep checked scalar conversions, integer failure domains, context-dependent + recipes and reduction ordering intact. Do not loosen admission merely to + increase benchmark coverage. +- Preserve safe-mode graph validation. Removing `numexpr.validate()` must not + introduce Python `eval` into safe mode. Preserve the existing full-mode policy + separately; changing the trust model is not a prerequisite for this removal. + +### Shared execution and storage + +- Extend existing graph/artifact APIs as needed so interpreter and JIT can bind + an external NumPy destination, including a serial direct-output path. +- Keep allocation policies such as `order` separate from execution-engine + options. Preserve the implemented native-eligible C / NumPy strided fallback + split until native strided sinks qualify; never restore layout-driven NumExpr + dispatch. Account for the NumPy fallback's intermediates in performance reports. +- Verify whether borrowed interpreter artifacts support the same binding and + lifetime contracts; do not assume the current JIT-only resident helper does. +- Reuse existing resident worker and prefilter machinery. Compressed output must + retain fused evaluate/filter/compress execution, not materialize a full NumPy + result before compression. +- Use capability-based thread admission, including artifact reentrancy and + invocation-local scratch. Join all workers before exposing errors or releasing + inputs/output, including submission failures. +- Support broadcasting/strides through existing native schedules/readers where + possible. Otherwise use a documented bounded fallback or explicit temporary + dictated by the operation's semantics. Report full-result copies when needed. +- Keep caches bounded and operand-free: expression, signature, semantic/backend + configuration and immutable preparation only. Rebind arrays, output, thread + policy and runtime state on each call. Test concurrent reuse and eviction. + +## 5. API and semantic decisions + +Create a compatibility table before implementation, distinguishing documented +Blosc2 behavior from incidental NumExpr behavior. NumPy-style promotion remains +the starting policy; exact NumExpr quirks are not the universal oracle. + +### Expression coverage + +Inventory arithmetic, comparison/Boolean/bitwise operations, shifts, integer +division/modulo/power, weak scalar captures, transcendental functions, `where`, +`copy`, `ones_like`, predicates, complex functions and string operations. +Include nested forms, namespaced calls, constant-only and scalar expressions. + +For reductions include axis/tuple axes, keepdims, empty inputs, initial/where, +accumulator dtype and staged/nested forms. Classify each as native interpreter, +native JIT, explicit NumPy fallback or unsupported by the public contract. + +### Output contract + +- Preserve output identity, exact shape requirements, 0-D outputs, read-only + rejection, order and supported casting policies. +- Preflight aliasing/overlap, reversed/strided/Fortran arrays, alignment, + byte order, empty domains and integer overflow-sensitive cases. +- Prefer direct writes. Any necessary temporary must have a stated reason, + bounded size where possible, and observable allocation accounting. +- `copy(x)` may lower to an identity graph node but must still copy into the + supplied destination or return independent storage when no output is supplied. + +### Keyword and exposed-API migration + +Audit `evaluate(**kwargs)`, `lazyexpr(ne_args=...)`, output/storage options and +all documented forwarding to NumExpr. Decide each option explicitly: + +| Option/surface | Proposed policy to review | +| --- | --- | +| `local_dict`, `global_dict`, internal frame depth | Preserve name resolution and caller scope; do not cache frames or mappings. | +| `out`, `casting`, `order` | Implement as Blosc2 contracts independent of backend; validate before writes. | +| `optimization`, `truediv` | Inventory accepted values and observable effects; implement supported semantics or document a staged deprecation. Never silently ignore arithmetic-changing options. | +| `sanitize` | Define compatibility with existing safe/full policy; it cannot disable mandatory safe-mode validation. | +| `disable_cache` | Define which preparation caches it bypasses consistently; retain if promised. | +| `ne_args` | Preserve as a compatibility spelling initially if needed, normalize internally, and propose a backend-neutral replacement only with an API migration decision. | +| `blosc2.numexpr` | Audit external-facing documentation/tests; remove or temporarily expose a deprecated `None` placeholder, never import NumExpr through it. | +| `NUMEXPR_*` environment variables | No effect on Blosc2 after removal; explain native thread/JIT controls instead. | + +Document release policy for removed options; avoid silently claiming a fully +drop-in NumExpr implementation when promotion or option semantics differ. + +### NumPy fallback boundaries + +- Complex construction/arithmetic: use approved NumPy operations where native + support is absent. Preserve infinities by assigning real/imaginary components + separately. Native complex kernels are a later optimization, not a removal gate. +- Strings: cover fixed-width bytes, Unicode and supported string dtypes explicitly; + test `contains`, comparisons and query selection without NumExpr. +- Datetime/timedelta: preserve unit promotion, `NaT` and comparison/arithmetic + distinctions. Raw-int64 comparison shortcuts require the existing semantic proof. +- Unsupported linalg and shape-changing operations: retain explicit NumPy/Blosc2 + implementations and their existing materialization contracts. +- NumPy expression evaluation may create intermediates. For compressed data, + preserve tile-local evaluation where valid; do not advertise fused execution + or bounded memory for inherently global fallbacks without evidence. + +## 6. Implementation phases and exit gates + +### Phase A — Freeze contracts and capture baselines + +1. Complete the dependency inventory and API option table. +2. Audit existing miniexpr tests before proposing additional native tests. +3. Capture representative output/dtype/error behavior and current route reports. +4. Run reproducible JIT, JIT-disabled and actual interpreter measurements; + distinguish API cost, preparation, execution, output allocation and copies. + +Exit: every runtime NumExpr use has an owner/replacement, and unresolved semantic +choices are recorded rather than hidden in implementation defaults. + +### Phase B — Interpreter/direct-output foundation + +1. Audit native interpreter binding, external output, status reporting, artifact + ownership, reentrancy and scratch requirements. +2. Add missing primitives in miniexpr or C-Blosc2 at the owning layer; expose only + necessary binding changes in `blosc2_ext.pyx`. +3. Qualify serial and parallel interpreter execution against the existing native + semantics, including direct NumPy sinks and prefilter invocation. +4. Refactor JIT-specific admission checks into semantic/backend capability checks. + +Exit: supported real maps execute without JIT or NumExpr, with direct output and +verified native route reports. Compressed sinks remain compression-driven. + +### Phase C — Replace internal evaluation and inference + +1. Introduce a backend-neutral replacement for `ne_evaluate` using existing + expression/native modules; avoid duplicating public and internal compilers. +2. Migrate chunk maps, selection, reductions, scalar construction and synthetic + metadata probes. Preserve caller scope and evaluation mode across wrappers. +3. Prefer native metadata inference over executing data; keep reviewed tiny NumPy + probes only for unsupported inference with documented warning/error behavior. +4. Replace the resident NumExpr program cache with shared native preparation or + the explicit NumPy fallback, then remove its locking/program machinery. + +Exit: runtime import blocking shows zero NumExpr accesses for the covered numeric +and fallback families, including LazyExpr and table/query consumers. + +### Phase D — Fallback coverage and API migration + +1. Complete complex/string/datetime/layout fallback contracts from section 5. +2. Implement reviewed keyword policies and any compatibility aliases. +3. Make dtype inference, casting and actual execution agree across all routes. +4. Convert essential tests from NumExpr-dependent expectations to NumPy/manual + contract references. Keep optional differential tests separate. + +Exit: full public behavior coverage runs with NumExpr absent; intentional changes +are enumerated in migration/release documentation. + +### Phase E — Remove dependency and platform integration + +1. Remove runtime imports, package dependency, initialization/thread handling, + diagnostics, helper names and obsolete comments. +2. Update docs, tutorials, examples and benchmark tooling; external comparison + tools should clearly report an unavailable optional reference engine. +3. Remove obsolete thread-coupling tests and add absence/independence tests. +4. Verify wheel metadata and install/test in clean environments without NumExpr. + +Exit: runtime source and package metadata contain no executable NumExpr +dependency; platform qualification passes with and without optional NumExpr +installed, producing the same Blosc2 dispatch decisions. + +### Phase F — Performance qualification and release decision + +1. Compare final performance against Phase A on matched hardware/configurations. +2. Profile remaining gaps rather than routing back to NumExpr. Prioritize small + preparation overhead, integer-input math admission and interpreter copy/maps. +3. Separate scheduling changes from kernel changes; validate error/lifetime + semantics for each broader parallel admission. +4. Publish native interpreter/JIT/NumPy-fallback coverage and residual regressions. + +Exit: review functional completeness and performance evidence independently. +Universal NumExpr parity is not claimed merely because dependency removal passes. + +Dependency order: A -> B -> C -> D -> E -> F. Inventory, fallback research and +benchmark design can inform B early; performance measurements run throughout. + +## 7. Testing and platform qualification + +### Tests at the owning layer + +- miniexpr: exhaustive numerical semantics, dtype/operator matrices, interpreter + versus JIT, FP status, overflow and native complex support if added later. +- C-Blosc2: worker/prefilter lifecycle, storage and compression integration. +- Python-Blosc2: binding contracts, dispatch, name resolution, output identity, + casting/shape validation, metadata, bounded scheduling, lifetime and a small + representative end-to-end semantic set. Avoid duplicating native matrices. + +Test cache rebinding and garbage collection, simultaneous callers, overlapping +buffers, failed submissions, failure propagation without replay, and unsupported +preparation falling back before writes. Test safe/full evaluation explicitly. + +### Dependency absence and isolation + +- Run mandatory suites in an environment with NumExpr genuinely uninstalled. +- Add an isolated subprocess test with an import blocker that fails on attempts + to import NumExpr, catching optional-import regressions as well as hard ones. +- Repeat representative operations with NumExpr installed and instrumented to + fail on use; installed optional dependencies must not affect dispatch. +- Ensure test fixtures do not silently skip core contracts through + `pytest.importorskip("numexpr")`; reserve that for external comparisons. +- Check wheel requirements/imports, documentation builds and supported examples. + +### Platform/backend matrix + +Qualify Linux x86-64 and available ARM64, macOS ARM64, Windows, and actual wasm32. +On hosts exercise interpreter-only, available JIT backends and unavailable-JIT +fallback. WASM uses its supported single-thread mode; do not demand host worker +speedups. Cover supported NumPy/Python versions via the existing CI matrix. + +Windows complex fallback must not introduce C99 `_Complex` assumptions. Actual +WASM tests must cover complex/strings and dtype widths; setting `IS_WASM=True` +on a host is only a dispatch probe, not platform qualification. + +For native changes, retain exact-revision qualification evidence and aligned +Python/native pins. Build isolated test packages where necessary, verify imported +extension paths, and do not overwrite another checkout's editable installation. +Use the `blosc2` conda environment for Python/build/test commands. + +## 8. Performance methodology and acceptance + +Extend the existing resident parity benchmark with explicit backend selection +and verified route reports; do not label “JIT off” as “interpreter” without proof. +Provide NumPy and optional NumExpr reference columns and retain `N/A` for failed +correctness qualification, without a verbose failure trailer in the main table. + +Benchmark dimensions: + +- Sizes: scalar/empty, small arrays (including 1k and 100k), 8M and 100M where + memory permits; separate cold preparation from warmed API calls. +- Inputs: float32, float64, representative integer/Boolean, plus fallback complex, + string and datetime cases; include non-contiguous/broadcast layouts. +- Recipes: copy/identity, arithmetic chains, division/power, transcendental math, + predicates/where and reductions. Keep overflow/accumulation differences explicit. +- Storage: resident, compressed and mixed inputs; NumPy and compressed outputs, + including explicit destinations. Preserve integer/arange/compression controls. +- Threads: serial and representative physical-core/SMT counts; avoid claiming + portability from a single M4 Pro result. + +Use randomized engine order, warmups and repeated samples. Publish medians and +variability. Keep fresh-output and reused-output experiments separate; report +logical read/write bandwidth as such, not measured DRAM traffic. Record native +revision, backend, compiler, versions, shapes/dtypes, geometry and thread counts. + +Track full-result temporary bytes, bounded scratch, copies, compressed bytes, +preparation/cache cost and allocation/first-touch effects when relevant. +Native copy must not hide a full-result allocation/copy behind a fast kernel time. + +Suggested review gates (to ratify after baseline collection): + +- No unexplained repeatable regression above 10% on established large-array JIT + paths; use variability to distinguish noise from regressions. +- Interpreter-only paths must be compared against the prior no-JIT behavior, + which may have used NumExpr. Any material regression needs an explicit decision + and an actionable profile; do not silently substitute NumPy to make a claim. +- Small-array cases report absolute overhead as well as ratios. Set budgets from + actual baselines rather than arbitrary thresholds. +- No new unbounded/full-result materialization on formerly bounded compressed + operations without an explicit documented semantic requirement. + +## 9. Principal risks and decision points + +| Risk | Required evidence or mitigation | +| --- | --- | +| Interpreter is correct but slower than the current fallback | Measure direct-output serial/parallel routes before removing NumExpr; profile native loops and scheduling independently. | +| NumExpr promotion was implicitly part of user-visible behavior | Inventory dtype/casting differences and decide them before routing changes. | +| Parallel admission changes integer/error semantics | Keep native proofs and error-domain tests; do not infer safety from successful ordinary values. | +| NumPy fallback creates large intermediates | Preserve tile evaluation and instrument memory; identify inherently global operations explicitly. | +| Native artifact/scratch cannot be shared concurrently | Qualify ownership and reentrancy; use invocation-local state or bounded worker contexts. | +| Removing validation changes safe-mode behavior | Keep graph/operand validation authoritative and test malformed/unapproved expressions. | +| Metadata probes disagree with execution | Prefer shared native inference; test fallback shape/dtype contracts and scalar promotion. | +| Platform-specific gaps surface late | Run actual Windows/WASM interpreter-only jobs during B–D, not just at dependency removal. | +| Thread controls change workload behavior | Document Blosc2 thread ownership and eliminate nested oversubscription. | + +Open decisions for review: public keyword deprecations, `blosc2.numexpr` migration, +required platform/backend coverage, performance regression budgets, and whether +native complex/string acceleration is scheduled after dependency removal. + +## 10. Final deliverables checklist + +- [x] Complete runtime-call inventory and compatibility/coverage table. +- [x] Native interpreter direct-output and shared scheduling qualification (local). +- [x] Backend-neutral internal evaluator and metadata/scalar migration. +- [x] Explicit NumPy fallback contracts and representative tests. +- [x] Removal of executable NumExpr integration, imports, thread controls and dependency; documented compatibility names remain. +- [ ] Clean-environment and import-blocking CI; actual Windows/WASM results. +- [x] Updated API docs, diagnostics, examples and migration notes. +- [x] Reproducible interpreter/JIT/fallback performance and bounded-memory report (local; release budgets still open). +- [x] Documented remaining gaps, intentional behavior changes and release decision point. diff --git a/plans/safer-lazyexpr-implementation.md b/plans/safer-lazyexpr-implementation.md new file mode 100644 index 000000000..e67334d7b --- /dev/null +++ b/plans/safer-lazyexpr-implementation.md @@ -0,0 +1,478 @@ +# Safer LazyExpr evaluation: two-phase implementation plan + +Date: 2026-10-08. Branch: `safer-lazyexpr`. +Status: experimental implementation in progress; exit gates are not complete. +See `plans/safer-lazyexpr-results.md` for implemented scope, measurements and gaps. +Current direction: narrow phase 1 first; ordinary in-memory defaults stay compatible. +Phase 2 and Menudet lowering remain opt-in experiments, not production defaults. + +## 1. Goal and recommendation + +Replace Python evaluation of expression text with a validated computation graph, +while preserving ordinary LazyExpr numerical behavior. First enforce the boundary +for safe deserialization, then consider making it the default for all LazyExpr +construction and execution after compatibility and performance measurements. + +Use Menudet as an optional backend for semantically compatible graph segments, +not as the definition of LazyExpr semantics. A trusted NumExpr/NumPy/Blosc2 +implementation is also a valid backend when invoked through explicit operations, +not Python evaluation of user text. Security and backend selection are separate. + +The separate branch is appropriate: do not make this a prerequisite for the +Menudet draft release, and do not assume that interpreter-only Menudet will +outperform existing expression engines. Advance each phase only after its gates +pass; retain the option to ship phase 1 without phase 2 or Menudet acceleration. + +## 2. Agreed policy and non-goals + +- Keep `deserialize="safe"` as the default. No new `safe_expr` switch on `open()`. +- Safe loading accepts supported numerical calls, reductions, methods and + indexing; it is **not** an arithmetic-only grammar. +- `deserialize="full"` is the explicit trusted-data escape hatch for legacy + expression reconstruction using the existing evaluator, where supported. + It does not promise recovery of arbitrary saved Python callbacks. +- Legacy DSL/Python UDF and table-kernel opt-in behavior remains unchanged. + Full-only nested payloads cannot become safe merely because their parent is a + validated expression. +- No silent semantic conversion to Menudet's checked arithmetic, operand-typed + promotion, logical block reductions, or independent table-row grouping. +- No new whole-LazyExpr portable format, migration tooling, native language + expansion, JIT expansion or universal libm accuracy promise in this work. +- Phase 1 does not restrict unrelated in-memory expressions. Phase 2 is a + separate compatibility decision, not an incidental side effect of phase 1. +- Phase 1 covers current structured LazyExpr recipes and persisted CTable + expression columns. Historical formats already requiring `"full"` retain that + gate; proxy/reference policy is unchanged. No historical-format migration. + +## 3. Threat model and precise safety claim + +Treat saved expression strings and their metadata as untrusted. Safe evaluation +must not resolve arbitrary Python names, call arbitrary functions or methods, +traverse arbitrary attributes, import modules, or execute Python source supplied +by the file. Allowed operations dispatch through explicit trusted implementations. + +An expression such as `sqrt(x)` is not inherently an exploit. The existing +regex validator alone does not establish this stronger boundary; no specific +exploit is asserted by this plan. The current broad Python fallback is the +execution surface being removed from safe-expression paths. + +The claim is limited to expression-text-driven Python execution. It is not a +process sandbox and does not eliminate native-library vulnerabilities, expensive +computations, large allocations, permitted filesystem/network reference access, +or behavior of custom operand objects deliberately supplied by trusted callers. +Reference resolution retains its existing policy; any stricter URL/path policy +must be specified separately. Resource bounds below limit parsing/graph abuse, +not all runtime resource consumption. + +## 4. Initial code inventory + +Inventory and classify all reachable routes before implementation: + +| Location | Current concern / integration point | +| --- | --- | +| `src/blosc2/b2objects.py` | `decode_structured_lazyexpr()` validates text, resolves operands, then calls the ordinary constructor; nested recipes recurse here. | +| `src/blosc2/lazyexpr.py` | `ne_evaluate()` merges caller locals and can fall back to `eval()` with broad Blosc2 globals; WASM uses a NumPy evaluation route. | +| `src/blosc2/lazyexpr.py` | Constructor handling, shape/dtype inference, slice rewriting, `compute()` and indexing contain additional text-evaluation routes. | +| `src/blosc2/lazyexpr.py` | `fast_eval`, `slices_eval`, `chunked_eval`, `reduce_slices` and reduction dtype helpers own scheduling and existing array semantics. | +| `src/blosc2/utils.py` | `infer_shape()` and NumPy namespace population must be checked for indirect evaluation and dynamic name resolution. | +| `src/blosc2/deserialization.py` | Immutable effective loading policy; currently missing-policy lookups can default to full, which must not be used to infer safe graph provenance. | +| `src/blosc2/msgpack_utils.py`, `core.py`, `schunk.py` | Frame/object dispatch, safe decoding and historical LazyArray gates. | +| `src/blosc2/ref.py`, stores and object containers | Recursive policy propagation and operand resolution. | +| `src/blosc2/ctable.py` | Saved expression columns are in phase-1 scope; filtering and deferred expression reconstruction must preserve their safe execution boundary. | +| `src/blosc2/portable_kernel.py`, `portable_lazy.py` | Menudet signature validation, native import and logical scheduling, reusable only under proven semantic eligibility. | + +Also trace UTF8 expressions, structured fields, `ColExpr`, CTable expressions, +RemoteArray/Proxy operands, NumPy ufunc construction and chained saved expressions. +Record each route as safe-graph, full-only legacy, trusted programmatic execution, +or out of scope. Do not claim whole-LazyExpr safety while leaving an undocumented +string-evaluation route reachable from a safe-loaded expression. + +## 5. Shared architecture + +### 5.1 AST parser and explicit operation registry + +Create a small package module, provisionally `src/blosc2/expression_graph.py`, +following existing naming/style conventions. Parse expression text with `ast` +and lower supported syntax to immutable graph nodes. Do not use `eval()`, +`exec()`, compiled Python expression code, or dynamic namespace population to +construct, infer or execute the safe graph. + +Each registered operation declares canonical name/aliases, argument and keyword +schema, type/shape rules, implementation dispatcher and backend eligibility. +Populate the registry from reviewed explicit entries, not all public callables +found in NumPy or Blosc2. Initially keep it internal; do not introduce an +arbitrary user-callback registration mechanism under the safe policy. + +Node families: operand, literal, unary/binary operator, comparison, approved +elementwise call, reduction, index/slice, supported constructor and shape operation. +Add selection, cumulative and linear-algebra nodes according to the compatibility +inventory, rather than treating them as unrestricted calls. + +Rules: + +- Operand names bind only to the explicitly resolved operand mapping. +- Calls resolve only to registry operations, never operand values or caller locals. +- Normalize supported spellings such as `sum(x)` and `x.sum()` to the same node. + Supported `np.sqrt(x)` / `blosc2.sqrt(x)` spellings, if retained, are syntactic + aliases for a reviewed operation, not namespace-object attribute lookup. +- `x.mean()` is a registered reduction, not generic `getattr(x, "mean")`. +- Validate positional/keyword arity and keyword types. Reject `*args`, `**kwargs` + and keywords that introduce arbitrary callbacks or file access. +- Reject arbitrary attribute chains, private/dunder names, lambdas, + comprehensions, assignment expressions and imports. Classify any presently + supported conditional-expression syntax explicitly before deciding its status. +- Indexing must specify supported integers, slices, ellipsis, new axes, field + names and explicit index operands. Build slices directly; never evaluate `np.s_` + text. Reject executable expressions disguised as indices. +- Scalar literals, typed scalar formatting, strings, `nan` and `inf` need explicit + rules; dtype specifications use validated descriptors, not imported classes. +- Preserve source spans for actionable diagnostics. +- Bound text size, AST node count/depth and literal sizes before costly lowering; + bound generated graph size and catch parser recursion failures predictably. + +### 5.2 Graph semantics and execution + +Keep a typed/shape-aware graph separate from backend compilation. Derive shape +and dtype from operation rules and operand metadata, without evaluating expression +text or computing the full input merely to guess metadata. Operations requiring +data-dependent output shapes must be explicitly represented or rejected with a +compatibility explanation; do not quietly infer them by Python evaluation. + +Reuse existing array scheduling and reduction implementations where possible, +through vetted dispatchers. NumExpr may remain a fast backend using text generated +from validated nodes and an explicit operand environment. User text is not passed +to the current broad `ne_evaluate()` fallback. Unsupported NumExpr operations +use a registered direct dispatcher or fail, never a Python-text fallback. + +Preserve broadcast shape, dtype promotion, scalar/array return conventions, +`out`, `where`, slicing, errors and warning behavior. Backend selection precedes +execution: arithmetic failures do not trigger a retry under different semantics. + +### 5.2.1 Operand admission and trusted adapters + +Define an explicit table of approved operand types and adapters before enabling +safe loading. An approved mathematical operation can still invoke arbitrary +Python through object-dtype arithmetic, ndarray subclasses or protocols such as +`__array__`, `__array_ufunc__` and `__array_function__`. + +Admission must precede coercion or metadata inspection that could invoke such +hooks. Do not accept an object merely because it has `shape` and `dtype`, and do +not treat `np.asarray()` as a safe admission check. Establish trusted concrete +types/adapters first, then obtain metadata or buffers through their reviewed +interfaces. Classify subclasses explicitly rather than inheriting trust from a +base class automatically. Approved container adapters must preserve nested +deserialization policy during reads as well as during initial resolution. + +The inventory must cover numeric and non-object NumPy arrays/scalars, Blosc2 +containers, structured fields and reference-backed operands actually supported +under the existing safe policy. Object arrays and custom protocol-bearing objects +need explicit classification; unsupported objects reject before invoking hooks. +This does not authorize broadening proxy/reference permissions. Phase 2 must +document separately how explicitly supplied trusted programmatic objects interact +with the safe expression boundary. + +### 5.2.2 Permissions, requirements and evaluation lifetime + +Separate caller permission from a node's execution requirements: + +- `deserialize="full"` permits legacy reconstruction; it does not make an + otherwise validated `sqrt(x)` graph inherently full-only. Prefer validated + reconstruction when compatible, even when full permission was supplied. +- Mark actual legacy-execution requirements on nodes/dependencies. Validated + graphs can compose regardless of their loading permission, provided their + entire dependency closure meets safe execution requirements. +- A graph with a legacy-only dependency cannot execute under safe permission. + Require an explicit trusted route; never infer elevated permission just because + one operand was opened with `"full"` or because a carrier is absent. +- Syntax alone is insufficient: an ordinary expression with a full-only proxy or + legacy-kernel operand still has that dependency's requirements. Safe eligibility + is derived by validation, not by trusting persisted flags or silently changing + an object's immutable deserialization policy. + +Use an evaluation context for intermediate reuse. For `x - mean(x)`, compute the +mean once per evaluation and reuse it across output chunks. Repeated reductions +may share intermediates within that evaluation when semantically equivalent. +Cache immutable parsing/compilation plans across evaluations, not computed values +that could become stale when operand data changes. Validate changed expression +text, bindings and relevant metadata before reusing a plan. + +Keep execution bounded-memory: reuse existing fusion/streaming, release temporary +buffers when their consumers finish, and avoid full-array materialization merely +to execute a graph node. Detect cycles in nested recipes and dependency graphs +before evaluation, while allowing legitimate shared dependencies. Bound recursive +recipe expansion separately from the size of each expression's AST. + +Preserve existing behavior under concurrent operand mutation; this work does not +add transactional snapshots or promise consistency across multiple reads. State +this explicitly when describing per-evaluation reuse and multi-pass reductions. + +### 5.3 Reductions are graph/scheduler operations + +Menudet already supports reductions over a declared logical group. That does not +make a per-chunk kernel equivalent to a LazyExpr global or axis reduction. + +| Expression | Intended graph plan | +| --- | --- | +| `sqrt(x) + y` | Eligible elementwise segment, then normal output scheduling. | +| `sum(sqrt(x))` | Elementwise segment followed by the existing whole-array reduction contract. | +| `x.mean(axis=0)` | Explicit axis reduction with its shape and promotion rules. | +| `x[0]` | Validated indexing node, with existing dimension-dropping rules. | +| `x - mean(x)` | Reduction dependency computed first, then broadcast into the elementwise stage. | + +Specify axes (including tuples/negative axes), `keepdims`, accumulation dtype, +empty inputs, identities, NaNs, masks and `ddof` where currently supported. +Inventory sum/prod/min/max/any/all/mean/variance/std separately; preserve the current +floating accumulation behavior rather than replacing it with an accidental block +combine order. A partial read of a result cannot redefine a global reduction's +input domain. Only introduce fused partial reductions after differential proof +and a documented combination algorithm. No whole-array-to-one-block workaround +that destroys bounded-memory evaluation. + +### 5.4 Menudet lowering is optional and semantics-gated + +Start with a narrow audited elementwise subset. Compare LazyExpr and Menudet +semantics for each operator/type combination, especially integer overflow, weak +literals, signed/unsigned mixtures, float promotion, casts, NaNs, short-circuiting +and warnings. Do not assume matching output dtype implies matching intermediates. + +Use explicit casts or typed temporaries only when they provably preserve the +LazyExpr contract; otherwise choose another approved backend. Complex, datetime, +object and other unsupported Menudet computations must not become blanket +LazyExpr exclusions. Object operations require a separate safety classification: +arbitrary Python operator dispatch is not safe just because it is called numeric. + +Draft Menudet is interpreter-only. Keep NumExpr/miniexpr expression fast paths +when they satisfy the graph boundary and outperform kernel lowering. Cache graph +parsing and backend plans using immutable graph content plus relevant dtype/shape, +backend/version and policy keys; never reuse a full-only plan as a safe plan. +Do not persist caches or use pickle as a new trust boundary. + +## 6. Phase 1 — safe deserialization end to end + +### P1.0 Establish the compatibility and reachability baseline + +- [ ] Inventory all evaluator routes and supported expression forms in section 4. +- [ ] Capture a versioned corpus from current tests/docs/examples, including + ordinary default-loading function/method/indexing round trips. +- [ ] Cover current structured LazyExpr recipes and persisted CTable expression + columns. Document historical formats that remain behind their existing full-only + gate, including applicable old LazyArray metadata. Never relax UDF/proxy gates. +- [ ] Define the approved operand/adaptor matrix and reject unsupported objects + before coercion, protocol dispatch or untrusted metadata access. +- [ ] Record baseline outputs, metadata, exceptions and representative timings. + +### P1.1 Build a thin end-to-end prototype first + +- [ ] Implement only the graph/registry operations needed for `sqrt(x) + y`, + `sum(x)`, `x.mean(axis=0)`, `x[0]` and `x - mean(x)` initially. +- [ ] Exercise save → safe reopen → inference → evaluation, plus composition and + partial reads. Keep the prototype isolated from production default routing + until the compatibility gate is met; these five expressions are not the final + supported subset. +- [ ] Prove existing schedulers can execute these nodes without returning to a + Python-text evaluator. Demonstrate global reduction scope and once-per-evaluation + intermediate reuse without cross-evaluation result caching. +- [ ] Benchmark the prototype against the existing engine immediately: opening, + planning, first/repeated execution, fusion, peak memory and partial reads. + Record results by elementwise/reduction/indexing family, not just an aggregate. +- [ ] Review integration feasibility before expanding the registry. If the design + forces full intermediate materialization or defeats existing scheduling, revise + the graph-to-scheduler interface first. Menudet lowering is not needed here. + +### P1.2 Expand the parser, registry and trusted graph executor + +- [ ] Implement shared architecture without changing ordinary in-memory defaults. +- [ ] Provide direct approved execution for common math, reductions and indexing + before enforcing the loader boundary; do not reintroduce the arithmetic-only + persistence regression. +- [ ] Add exhaustive positive/negative parser and signature tests. +- [ ] Add a capability matrix: safely supported, full-only legacy or unsupported. + +### P1.3 Integrate safe loaders and preserve graph provenance + +- [ ] Parse/validate recipe syntax and call signatures **before** resolving its + operands, so an invalid parent cannot trigger needless reference access. +- [ ] After permitted reference resolution, validate operand types, shape and + graph contracts; construct the graph without the ordinary text evaluator. +- [ ] Propagate `deserialize` unchanged through disk, frames, MessagePack, + nested containers, stores, references and CTable expression recipes. +- [ ] Safe-loaded expressions retain a safe execution graph through `compute()`, + indexing, reductions, ufunc composition, `where`, copies and nested expressions. + No deferred fallback to Python text evaluation after opening. +- [ ] Handle mutable public expression text/operand mappings: invalidate and + revalidate against the safe policy, or reject the mutation explicitly. Never + use a stale graph after mutation or downgrade because a carrier is absent. +- [ ] Track actual execution requirements separately from loading permission. + Validated graphs opened with `"full"` can compose with safe graphs; dependencies + requiring legacy execution must reject or use an explicitly trusted route. +- [ ] Preserve existing recipe format where feasible: compile its text on load. + Do not trust a persisted "safe" flag or prevalidated graph claim. Version any + unavoidable format change explicitly; revalidate every safe load. +- [ ] Full loading prefers compatible validated reconstruction and permits the + existing supported legacy route where necessary. Mark actual legacy requirements + after composition; existing structural validation still applies. Numerical + execution failures never trigger legacy retry. +- [ ] Implement per-evaluation intermediate reuse, bounded-memory scheduling and + dependency-cycle detection; cache plans, not operand-dependent results. +- [ ] Errors identify the disallowed operation/location and explain the trusted + `deserialize="full"` alternative; do not suggest that full recovers any callback. + +### P1.4 Security and compatibility verification + +- [ ] Test approved numerical expressions through every supported persistence + entry point and ordinary default reopening. +- [ ] Test global/axis reductions, fixed strings, datetime/complex approved routes, + constructors, broadcasting, indexing, fields and partial reads from the corpus. +- [ ] Test forbidden callables, attribute traversal, namespace aliases, caller-local + shadowing, malformed keyword arguments and hostile index/constructor arguments. +- [ ] Use harmless sentinel operand objects/subclasses to prove unsupported types + reject without invoking coercion, ufunc, array-function or metadata hooks. +- [ ] Test safe/full-opened validated graph composition separately from graphs + with actual full-only dependencies, including proxies and legacy kernels. +- [ ] Test shared dependencies versus cycles, recursive recipe expansion bounds, + reduction reuse across chunks and reevaluation after operand data changes. +- [ ] Assert forbidden recipes fail before operand resolution and before callbacks + or side effects. Use harmless sentinels, never destructive exploit payloads. +- [ ] Instrument each Python-text evaluation bridge reachable from safe graphs to + fail if invoked. Exercise construction/inference, first and repeated execution, + mutation/composition, fallback, WASM and nested recipes, not only loader calls. +- [ ] Retain tests proving legacy kernels, proxies and other full-only nested + payloads still require full. Verify the explicit full compatibility route. +- [ ] Add bounded parser fuzz/property tests and differential graph tests. +- [ ] Document the limited safety claim and known resource/reference boundaries. + +### Phase-1 exit gate + +All currently supported ordinary numerical persistence cases in the agreed corpus +must work with safe graph reconstruction. Any deliberate exclusion requires an +explicit capability entry and user review, not changing tests to `"full"` merely +to regain green CI. No Python-text evaluator may be reachable from a safe-loaded +graph's lifetime. Approved operand adapters and execution requirements must enforce +the same boundary. Platform suites and phase-1 performance checks must pass: +preserve fusion/streaming and review time and memory regressions by workload family, +using the provisional budgets below. Menudet lowering is optional at this gate. + +## 7. Phase 2 — all LazyExpr construction and execution + +Begin only after reviewing phase-1 results. This phase changes the default boundary +for string-based construction and replaces internal text-based reconstruction in +programmatically built expressions as well. + +### P2.0 Decide the public compatibility escape hatch + +- [ ] Propose and obtain approval for a construction/evaluation policy on + `blosc2.lazyexpr()` and relevant constructors/context APIs. Naming is not yet + decided; prefer one explicit safe/full policy, not conflicting Boolean switches. +- [ ] Distinguish this execution policy from `deserialize`, which applies to + loading. No new parameter on `open()` is necessary. +- [ ] Preserve ordinary Python functions that **build** graphs, e.g. + `expr = helper(x, y)`. Their trusted Python execution is outside expression-text + parsing; `"helper(x, y)"` is not an approved safe call unless it names a builtin + reviewed operation. LazyUDF remains a separate explicit Python execution API. +- [ ] Preserve convenient operand discovery from caller locals where compatible, + but discover only validated operand names. It must not expose callable names, + modules or globals as an execution namespace. + +### P2.1 Make graphs the canonical in-memory representation + +- [ ] Build graph nodes directly for overloaded operators, ufuncs, methods, + `ColExpr` and table expressions rather than stringify-and-evaluate cycles. +- [ ] Treat expression text as display/serialization output, with explicit + round-trip rules; preserve documented `.expression`/`.operands` behavior or + publish a reviewed compatibility change. +- [ ] Apply the same registry to string constructors and later compute paths. +- [ ] Cover shape/dtype inference, constructors, UTF8 dispatch and operations + currently delegated to NumPy. Unsupported operations fail with precise errors. +- [ ] Keep trusted legacy execution only through the approved explicit policy. + Never choose it because a fast backend lacks a feature. +- [ ] Expand Menudet eligibility only with differential semantic evidence and + measured benefit; do not silently replace numerical contracts. + +### P2.2 Benchmark before changing defaults + +Start a reproducible driver under `bench/ndarray/` during the phase-1 prototype, +provisionally `safer_lazyexpr.py`, writing machine-readable results. Expand it +here to the complete workload matrix. Compare the pre-change baseline, safe graph +with established backends, and eligible Menudet segments. The first performance +goal is preserving established fusion and scheduling, not replacing the backend. + +Measure separately: + +- Parse/construct time, shape/dtype inference, cold compilation, cached planning. +- First execution, repeated execution and amortized end-to-end cost. +- Persistence/open cost and first evaluation after opening. +- Peak resident memory, intermediate allocation size and bytes read/written. +- Backend choice and reason, so speedups cannot hide changed coverage/semantics. + +Workload matrix: + +- Tiny arrays (dispatch overhead), cache-resident arrays, and compressed streaming + arrays exceeding cache; in-memory and disk-backed variants. +- Simple arithmetic; `sqrt`/trig/exp composites; comparisons and selection; + multiple operands and scalar broadcasting; rank/broadcast variations. +- Global and axis reductions, `x - mean(x)`, empty and scalar outputs, cumulative + operations where supported, slices/strides and indexing-heavy workloads. +- Float32/64, supported integer widths/mixes, fixed strings, complex and datetime + trusted-backend routes. Report unsupported combinations rather than omit them. +- Aligned/misaligned chunk and block shapes, compressibility levels, thread counts, + and repeated graph reuse with changed operands. +- Representative CTable expression filters/computed columns, without conflating + their semantics with independent-row Menudet kernel registration. + +Run with pinned dependency versions, fixed seeds and documented hardware/thread +settings. Use warmups, repeated randomized-order trials, medians and dispersion; +validate outputs before comparing timing. Avoid timing assertions in ordinary CI. +Use the required `blosc2` conda environment for local Python/tests/builds. +Report each workload and family separately (elementwise, reductions, indexing, +constructors and table operations), including worst regressions and absolute +latencies. An overall geometric mean must not conceal a failing family. + +Proposed acceptance targets, subject to review after baseline collection: +no more than 5% geometric-mean regression on established large-array workloads, +investigate every reproducible regression over 10%, and no unexplained material +memory-growth regression. Report tiny-array absolute latency separately (relative +ratios are misleading there). These are review gates, not reasons to weaken safety +or skip workloads. If targets fail, optimize planning/caching or retain the faster +approved backend; defer phase 2 when necessary. + +### Phase-2 exit gate + +The compatibility matrix and explicit trusted escape hatch are approved. All safe +construction/evaluation routes are graph-based; platform correctness/security +tests pass. Benchmark reports support the default change, with every remaining +regression and limitation reviewed. Do not infer this gate from phase-1 CI success. + +## 8. Delivery sequence and checkpoints + +1. Inventory/corpus/threat-model review within the defined phase-1 scope; specify + trusted operand adapters and permission/requirement rules. +2. Thin five-expression end-to-end prototype and early time/memory benchmarks; + review scheduler integration before building the full registry. +3. Expand parser/registry and direct executor with isolated tests; no default changes. +4. Safe loader integration and graph lifetime/policy propagation; retain full route. +5. Phase-1 differential/security/platform tests and per-family benchmark report. +6. Review whether to release phase 1, continue experimentally, or stop. +7. Phase-2 API decision, direct graph construction and wider route coverage. +8. Optional narrow Menudet lowering and plan caching, measured independently. +9. Complete benchmark/platform review before approving phase-2 default expansion. + +Maintain a progress log with completed gates, excluded forms, semantic differences, +benchmark artifacts and exact CI revisions. Run Ruff/format, doctests, the default +suite, relevant opt-in tests, native/WASM and installed-wheel tests. If Menudet +lowering changes, also run portable conformance and the independent math corpus. +No release publication or unrelated API changes are authorized by this plan. + +## 9. Decisions to review before coding + +- The operation inventory and any forms requiring explicit full mode. +- The route inventory implementing the defined phase-1 scope: current structured + LazyExpr and CTable expression recipes, with historical full-only formats and + nested legacy/proxy gates retained. +- Parser limits and policy for object/custom operands and data-dependent shapes. +- Phase-2 construction-policy API and mutable expression compatibility. +- Final performance budgets after reproducible baseline collection. +- Which Menudet segments are both semantically equivalent and worth accelerating. + +The recommended initial experiment is **safe graph reconstruction with existing +numerical backends**. It provides the safety benefit directly; Menudet integration +can then be evaluated without confusing safety with a performance/backend rewrite. diff --git a/plans/safer-lazyexpr-results.md b/plans/safer-lazyexpr-results.md new file mode 100644 index 000000000..4827eff62 --- /dev/null +++ b/plans/safer-lazyexpr-results.md @@ -0,0 +1,1036 @@ +# Safer LazyExpr experiment: implementation and initial results + +Date: 2026-10-08. Branch: `safer-lazyexpr`. + +**Status: narrowed phase-1 experiment. Ordinary in-memory defaults are restored; +safe loading uses graph execution. Exit gates remain incomplete. Not ready to merge.** + +## Implemented + +- `expression_graph.py` parses bounded ASTs into immutable tuple graphs with an + explicit numerical-operation allowlist. Registered namespace spellings are + syntax aliases, not arbitrary namespace traversal. +- Numerical source execution in `lazyexpr.py` now routes through the graph bridge; + the only Python `eval()` bridge is gated by the trusted evaluation context. +- Structured recipes validate syntax before reference resolution. Recursive + recipe expansion is bounded, and dependency validation rejects cycles while + permitting shared dependencies. +- Ordinary construction/evaluation retains the trusted legacy default. Safe loading + establishes its own graph boundary. Explicit `evaluation="safe"` or + `with blosc2.expression_evaluation("safe"):` exercises graph execution in memory. + These are experiment APIs, not an approved public API freeze. No new `open()` + parameter was introduced. +- Deferred dtype, shape and compute routes restore expression policy and + revalidate changed text/bindings. Parsing plans are cached, never operand data. +- Full loading prefers safe numerical reconstruction when eligible. Existing + legacy UDF loading gates remain; source-reconstructed UDF dependencies are + rejected by safe graph admission. +- Existing NumExpr/miniexpr and chunk/reduction schedulers remain in use. No + Menudet lowering or reinterpretation of LazyExpr semantics was added. +- Added disk/frame/in-memory round trips for the five prototype expressions, + hostile operand/subclass tests, forbidden recipes before reference resolution, + graph mutation and cycle checks, caller-function shadowing and parser bounds. + +## Current capability boundary + +| Category | Experimental behavior | +| --- | --- | +| Registered numerical calls, reductions, indexing, constructors and shape operations | Validated graph dispatch; existing schedulers/inference reused. | +| Exact non-object NumPy arrays/scalars | Admitted; ndarray subclasses and object dtype reject. | +| Concrete Blosc2 arrays, fields, columns, remote/storage adapters | Explicit types admitted; complete adapter/provenance audit still outstanding. | +| Numeric concrete pandas Series | Adapted via its concrete NumPy storage; extension arrays reject. | +| Caller-authored in-memory LazyUDF | Trusted caller capability, not constructible by saved graph text; source-reconstructed legacy UDF rejects. | +| Arbitrary array-protocol objects | Ordinary in-memory compatibility preserved; reject under the safe graph policy before metadata/protocol hooks. | +| Unregistered calls, arbitrary attributes, lambdas, comprehensions, starred arguments and file-writing constructor keywords | Reject before operand resolution for structured recipes. | + +The safety claim is limited to expression-text-driven execution. Native-library +bugs, large allocations, costly computation, permitted external references and +explicit caller-supplied UDF capabilities are not sandboxed. This experiment does +not establish a new security guarantee for all admitted adapter implementations. + +## Verification and benchmarks + +Initial two-phase local run: **11,334 passed, 55 skipped** (includes 43 new graph +tests). The narrowed phase-1 follow-up passed **11,338 tests, 55 skipped**. Ruff +lint/format and tracked whitespace checks passed for the follow-up changes. + +Benchmark driver: `bench/ndarray/safer_lazyexpr.py`. The historical control uses +an immutable `git archive HEAD` source snapshot and the same compiled extensions, +not the modified branch's full-mode evaluator. Workers verify their import path, +use one computation thread, check outputs, and record construction, first/repeated +execution, reopening and process peak RSS. Inputs are compressible linspaces; +this is preliminary, not the full plan's workload matrix. + +| Measurement | Initial observation | +| --- | --- | +| Float64, 1M elements, seven families, 9 repeats | Execution geometric mean ratio 1.043. Math/reopening initially approximately 1.29/1.30; these did not reproduce in the follow-up. | +| Float64, 1M elements, follow-up, 15 repeats | Execution geometric mean ratio 1.001; individual ratios 0.913–1.059. | +| Float32, 1M elements, 9 repeats | Execution geometric mean ratio 0.971; individual ratios 0.874–1.040. | +| Float64, 1K elements | Several execution regressions approximately 13–21%; construction overhead also visible. | +| Peak RSS, float64 follow-up | Ratios 0.744–1.571; math/indexing memory increases need dedicated measurement and explanation. | + +Ratios are experimental/current divided by historical baseline; below 1 is +faster. These short local runs are noisy and do not establish statistical +significance or pass the complete performance gate. + +## Outstanding completion gates + +1. Finish the route and adapter inventory, including nested proxy/reference policy, + deferred CTable materialized-expression reconstruction and all composition + routes. Exact wrapper type admission alone does not establish closure safety. +2. Replace provisional signature families and reused dummy inference with precise + per-operation schemas, keyword-value contracts and typed/shape-aware graph + rules. Method/function normalization is not yet complete. +3. Prove once-per-evaluation reduction reuse and bounded-memory execution across + chunks, partial reads and fallback routes; graph-local caching alone is not a + scheduler-wide proof. Add allocation/materialization instrumentation. +4. Expand differential/property tests and bridge instrumentation across the full + graph lifetime and all persistence containers. Validate WASM, platform and + free-threaded behavior; only local macOS verification was performed here. +5. Complete the benchmark matrix: compression distributions, shapes, dtype + families, partial reads, selection, strings, datetime/complex, persisted CTable + recipes and multi-threaded workloads. Investigate RSS and small-array overhead. +6. Review the phase-2 API and compatibility exclusions before changing production + defaults. Phase 2 is no longer enabled by default in this experiment. + +Recommendation: retain as an experiment until those gates pass. The initial +numerical compatibility and large-array timings support further investigation, +but do not justify a merge or a completed two-phase claim. + +## Follow-up: narrow phase 1 and close deferred-policy gaps + +Following review, ordinary in-memory construction is trusted again. Safe graph +execution is established by safe loading or explicit experimental opt-in. A +safe ambient context takes precedence over a dependency's trusted construction +mode; safe-loaded expressions cannot be downgraded by entering trusted mode. +Programmatic constructors propagate a safe operand's boundary before coercion, +and validate the resulting dependency closure. Functionally numerical expressions +constructed in trusted mode can participate without making that context a +requirement for legacy execution. + +Additional closure checks inspect NDField owners, ProxyNDField/Proxy sources, +SimpleProxy sources, portable inputs and Column dependencies. Legacy DSL table +dependencies reject; caller-authored UDF inputs use the same cycle guard. These +checks are a concrete improvement, not a completed audit of every storage adapter. + +Loaded CTable computed recipes reconstruct with the effective loading policy. +Generated-expression metadata gets a runtime-only policy derived from storage, +not a persisted safety flag. Append/refill/refresh reconstruction uses that policy. +Safe loading validates both computed and materialized expression syntax. Reduction +and selection methods restore graph context; selection dependencies are admitted +before coercion and revalidated on later computation. + +New regressions instrument the legacy eval bridge while reopening a graph outside +the safe test context, composing/selecting/reducing it, mutating it, and reopening +and appending to a table with computed and stored expression columns. The existing +minimal-protocol compatibility test again uses ordinary construction without an +explicit permission override. + +No Menudet lowering was attempted: completing the graph boundary remains the +prerequisite. Precise operation contracts, metadata invalidation, full adapter +inventory, scheduler-wide reuse proofs and platform checks are still outstanding. + +### Follow-up performance + +Two sequential float64 runs (1K/1M elements, seven families, 15 repetitions) used +the same historical source snapshot and matching compiled extensions. Safe graph +execution versus historical execution at 1M elements had geometric mean ratios +**1.021** and **1.048**. These aggregates conceal reproducible family regressions: +centering ratios **1.232/1.273**, and persisted reopening/execution workload ratios +**1.196/1.388**. In the final run, repeated execution for centering was 5.70 → +7.26 ms and for the persisted workload 3.76 → 5.22 ms. The latter times measure +execution after reopening; the driver records open time separately. + +Small-array safe execution also retains approximately 14–26% overhead in several +families. Ordinary construction now uses the compatibility route, but these +measurements exercise explicit safe graphs, not that restored ordinary default. +Peak RSS remains variable; no claim of a memory improvement is justified. + +The repeated >10% regressions are an outstanding performance gate, not excused by +the geometric mean. Further profiling should separate recursive closure validation, +graph/dummy inference and scheduler reconstruction before adding another backend. + +## Profiling checkpoint (after `5b582dfb`) + +The phase-1 checkpoint was committed as `5b582dfb`. The subsequent profiling work +does not alter the runtime or weaken any validation. + +The benchmark now supports `--families`, independent `--rounds` with alternating +baseline/safe process order, and worker-only `--profile-output`. Profiling is +enabled only around repeated evaluation, excluding construction, opening, output +checking and imports. Profiled timing results must not be used as uninstrumented +performance evidence. + +### Isolated repeated-execution profiles + +101 evaluations of each million-element workload, historical source control with +matching extensions: + +| Profile | Total profiled seconds | Native reduction seconds | Compressed-output update seconds | Operand validation cumulative seconds | +| --- | ---: | ---: | ---: | ---: | +| Centering, safe | 0.699 | 0.263 | 0.263 | 0.010 | +| Centering, historical | 0.775 | 0.300 | 0.316 | n/a | +| Persisted expression, safe | 0.489 | n/a | 0.387 | 0.004 | +| Persisted expression, historical | 0.433 | n/a | 0.339 | n/a | + +These profiles do not explain the previous large ratios as validation overhead: +native work dominates, and its timings vary between processes. Cumulative decorator +and dispatcher times include numerical execution; they are not boundary overhead. +The centering profile contains exactly 101 whole-array reductions for 101 repeated +evaluations, in both implementations. A new multi-chunk regression also asserts +one reduction per evaluation and recomputation after operand data changes. + +### Longer, uninstrumented repeated-process measurements + +Five sequential rounds, alternating process order, 50 repetitions per worker, +float64, 1M elements, the same historical control: + +| Family | Median of per-round execution ratios | Per-round range | +| --- | ---: | ---: | +| Centering | 0.955 | 0.859–1.000 | +| Persisted expression execution | 0.948 | 0.811–1.007 | + +The earlier >20% regressions did not reproduce under this longer protocol. This +does not prove an improvement: native timing variation, allocator/compression state +and process order remain confounders. Construction is still slower: round ratios +are 1.018–1.153 for centering and 1.176–1.273 for the persisted workload. The +small-expression overhead and RSS question remain open. + +Conclusion: there is not enough evidence to justify a more complex validation +cache or a new engine as a performance fix. Retain the boundary, use the improved +measurement protocol for future changes, and prioritize precise operation/metadata +contracts and the remaining adapter/lifetime audit. No Menudet lowering yet. + +Profiling follow-up verification: **11,339 passed, 55 skipped**; Ruff lint/format +and whitespace checks passed. Profiling artifacts remain in the approved temporary +directory; the runtime itself is unchanged from the committed checkpoint. + +## Metadata validity follow-up (after `0c92a0d5`) + +The profiling checkpoint was committed as `0c92a0d5`. The next implementation +step addresses cache correctness, not performance shortcuts or Menudet lowering. + +Previously, safe construction could cache `_shape`/`_dtype`, then return those +values after rebinding a public operand, resizing an admitted NumPy operand, or +editing expression text. Persistence could also select `expression_tosave` and +`operands_tosave` from the original construction instead of the current recipe. + +Safe graphs now record an input-metadata signature at construction and check it +at deferred entry points, including chunks/blocks and recipe export. The signature +includes expression text, bindings, admitted shape/dtype/partition metadata, +nested expression metadata and selection dependencies. It contains no array data +or computed results. Data-only changes therefore reevaluate without metadata +reconstruction. Changed signatures trigger inference through the existing validated +constructor before replacement caches become visible. Failed inference cannot +return old metadata. Trusted numerical dependencies entering a safe graph also +refresh potentially stale constructor caches. + +After a metadata change, derived caches and the original persistence recipe are +invalidated. Disk, frame and nested structured encoding select the current recipe. +The ordinary trusted path's existing mutation behavior is unchanged. + +New regressions cover rebinding before first computation, shape/text changes, +selection dtype changes, data-only updates, disk/frame/structured round trips, +trusted dependency metadata and incompatible rebinding. This is **not** a new +typed inference engine: precise per-operation rules and complete synchronization +of wrapper/source metadata are still outstanding. In particular, wrapper-owned +cached metadata and graph-dependent constructor caches need further audit. No +transactional snapshot or concurrency guarantee was introduced. + +Verification: **11,348 passed, 55 skipped**. A repeated-execution centering profile +spent approximately 0.007 seconds in metadata refresh across 101 evaluations +(0.747 seconds total profiled execution). This is diagnostic, not a timing gate. +Three uninstrumented alternating-order historical-control rounds at 1M float64 +elements, 50 repetitions each, gave centering median ratio 1.089 (range +0.896–1.125) and persisted-execution median 0.960 (0.836–1.029). Timing variability +remains material; no performance improvement or complete gate pass is claimed. + +## Reduction/cast contracts follow-up (after `2158e7e0`) + +The metadata checkpoint was committed as `2158e7e0`. The next slice replaces the +single broad reduction keyword set with explicit per-operation contracts shared +by parsing and direct dispatch. Contracts cover axis forms, duplicate axes and +arguments, keepdims, accumulation dtype descriptors, variance degrees of freedom, +and mutually exclusive ddof/correction. Known malformed literals reject before +operand/reference resolution. Bound argument values are checked before direct +backend dispatch. Parser-time checking reads literals only; it never executes an +expression or folds potentially expensive arithmetic to validate an argument. + +NumPy `astype` contracts validate dtype, order, casting and boolean flags. They +are currently implemented only for admitted NumPy arrays; there is no registered +streaming Blosc2 cast, and no whole-array materialization fallback was introduced. +Safe validation now uses the graph parser rather than requiring agreement with +the legacy broad method-name filter. Ordinary trusted validation remains unchanged. + +These are initial per-operation argument contracts, **not** complete type/shape +rules or a canonicalized reduction API. Positional layouts beyond common prefixes +remain receiver-dependent; NumPy and Blosc2 differ, so blindly normalizing them +would change existing semantics. Remaining keyword families, backend-specific +signatures, rank-dependent axis validation and metadata rules still need review. +Boolean flags are admitted as concrete Python/NumPy booleans, not arbitrary +truth-coercible objects. Object-dtype cast/accumulation targets remain excluded. + +### A correctness bug exposed by the new contracts + +Graph nodes previously keyed literal intermediates by `(literal, value)`. Python +considers `True`, `1`, `1.0` and `1+0j` equal as dictionary keys. Consequently a +cached integer could replace a boolean keepdims flag or a floating literal, +changing numerical promotion or making an otherwise valid reduction fail. + +Literal nodes now include their concrete type in their immutable identity. Tests +verify exact scalar types, mixed-type promotion and keepdims round trips, while +also confirming that equivalent reduction nodes still reuse one intermediate +within an evaluation. No cross-evaluation result cache was added. + +Verification: **11,377 passed, 55 skipped**. New tests cover malformed recipe +contracts before resolution, runtime bound-axis rejection before dispatch, +positive axes/keepdims/casts, persisted reduction round trips and typed literal +cache identity. No performance or cross-platform gate pass is claimed for this +slice; the remaining adapter/lifetime and operation-metadata audits remain open. + +## Follow-up: backend-specific reduction binding and root metadata + +Reviewed reduction layouts now distinguish NumPy, Blosc2 functions, array +methods and LazyExpr methods. In particular, NumPy's positional `out` is not +Blosc2's `keepdims`, and array versus LazyExpr `std`/`var` methods have different +`ddof` positions. Duplicate arguments, unsupported reviewed backend keywords and +rank-dependent axis bounds reject before dispatch. Explicit `np`/`numpy` and +`blosc2` reduction namespaces retain their selected backend rather than becoming +interchangeable aliases. + +Safe construction normalizes positional arguments for root reductions on direct +named operands. Data-free shape and a limited dtype-rule subset bypass executing +reductions on tiny inference dummies, including otherwise valid `ddof` cases. +Normalization preserves typed arguments and leaves non-reduction grouping alone. +Full-permission safe-eligibility checks also consider reviewed root binding. + +This is not complete graph-wide type inference: nested expressions, table-specific +receivers, cumulative operations, casts and other operation signatures still need +review. Half-precision fallback promotion, boolean extrema, complex statistical +reductions and integer statistical dtype overrides retain existing inference where +the independently specified rules are incomplete. Existing complex-extrema warning +failures are preserved, not silently redirected to NumPy. + +Verification: **11,498 passed, 55 skipped**. Differential tests cover receiver +layouts, reduction dtype/shape families, namespace selection, axis validation, +output positions, persistence and data-free inference instrumentation. Ruff lint, +format and whitespace checks passed. No new benchmark or platform gate is claimed; +the experiment remains incomplete and is not ready to merge. + +## Follow-up: cumulative-operation contracts and metadata + +Reviewed `cumsum`/`cumprod` and `cumulative_sum`/`cumulative_prod` separately. +NumPy's newer cumulative functions accept keyword-only options; Blosc2 functions +and array methods accept positional dtype/include-initial, while LazyExpr methods +use positional include-initial without a dtype slot. The safe binder now preserves +those layouts and validates concrete boolean `include_initial` values, duplicate +arguments and scalar axes. Blosc2 cumulative `out` is not registered; NumPy's +supported output slot remains available. + +Direct named-input root metadata now describes legacy flattening for `axis=None`, +the newer APIs' one-dimensional requirement when axis is omitted, and the +one-element shape extension for `include_initial`. Supported dtype/shape inference +does not execute cumulative work on dummy arrays. NumPy-qualified operations also +use NumPy dtype rules even when their input is a Blosc2 operand. + +The current Blosc2 cumulative backend does not consistently honor explicit dtype +overrides. Those cases retain existing inference and execution semantics, covered +by differential tests; this change does not fix or silently reinterpret that +backend behavior. Nested graph metadata, other signatures, half-precision fallback +rules and complete streaming/allocation audits remain outstanding. + +Verification: **11,580 passed, 55 skipped**. Added differential receiver/layout +tests, flattening and output-position checks, include-initial persistence, invalid +contract rejection, data-free inference instrumentation and operand-rebinding +metadata coverage. Ruff lint/format and whitespace checks passed. No new benchmark +or cross-platform completion claim is made. + +## Follow-up: nested shape propagation and wrapper/source synchronization + +Added data-free graph shape propagation for scalar/array inputs, elementwise +broadcasting, unary operations, comparisons and basic indexing. Reviewed +reductions now contribute shapes inside enclosing arithmetic/functions; function +reductions can also consume reviewed intermediate shapes. Positional binding +uses the selected backend rather than the old shape inferencer's universal slots. +Incompatible broadcasting rejects before dummy execution. Data-dependent indexing, +matrix multiplication, unreviewed receiver layouts and other unsupported rules +explicitly return unknown and retain existing inference. This is not graph-wide +dtype inference: nested dtype promotion and dummy-reduction removal remain open. + +The initial adapter audit found stale source metadata in SimpleProxy and NDField. +After recursively admitting the source, safe validation refreshes SimpleProxy's +shape/dtype and rank-dependent partitions. NDField validation refreshes field +dtype, offset and partitions after parent rebinding, or rejects a removed field. +Hostile rebound sources and cycles reject before metadata or compute hooks, +including under an ambient full evaluation context. Ordinary trusted-only +construction has not acquired this synchronization policy. + +The scheduler's indexing-to-`.slice` rewrite also exposed a NumPy adapter mismatch: +NumPy has no NDArray-style slice method. Safe dispatch now uses direct indexing +for exact admitted NumPy arrays, with one index and no constructor keywords. +This introduces no whole-array conversion or streaming Blosc2 cast fallback. + +Verification: **11,598 passed, 55 skipped**. Tests instrument shape inference +against data reads, compare nested reductions/indexing against NumPy and exercise +wrapper resizing, rebinding, changed field layouts, removed fields and cyclic or +hostile sources. Ruff lint/format and whitespace checks passed. Caching proxies, +table/storage/remote adapters, full persistence reachability and allocation bounds +still require audit; this slice does not establish complete adapter lifetime safety. +Construction overhead and cross-platform behavior were not newly measured. + +## Follow-up: nested unary dtypes and caching-proxy admission + +Added a narrow data-free dtype traversal for numeric named inputs, basic indexing, +reviewed direct-input reductions and selected unary numerical calls. Unary output +types use NumPy ufunc dtype resolution, not evaluation of synthetic values. With +reviewed shape and dtype rules, construction now skips both dummy execution and +slice-placeholder creation. Nested cases such as `sqrt(x.std(axis=0, ddof=2))` +therefore no longer perform invalid reductions on tiny all-one dummies. Unsupported +binary promotion, weak scalar rules, intermediate reduction receivers, casts and +backend-specific exceptions retain existing inference. This remains a subset, not +a complete independent graph type system. + +Proxy construction records the source owning its cache. Safe admission rejects +subsequent source rebinding, including equal-metadata replacements and rebinding +before first expression admission. Source/cache shape, dtype, chunks and blocks +must agree; the cache must be an admitted concrete NDArray. Failures occur before +fetching, with no cache writes, discard or automatic reconstruction. The diagnostic +asks callers to construct a new proxy. ProxyNDField metadata now refreshes after +rebinding to a valid proxy and rejects missing fields. + +These checks establish neither cached-data freshness nor transactional snapshots. +They do not replace the proxy's existing stamp/refresh policy, certify adopted +persistent-cache contents, or complete the remote-source refresh/lifetime audit. +Table/storage/remote adapters and full persistence/container reachability remain +open. Ordinary trusted-only evaluation retains its compatibility behavior. + +Verification: **11,660 passed, 55 skipped**. Differential unary/reduction dtype +tests cover NumPy and Blosc2 inputs, boolean/integer/float/complex families, metadata +rebinding and persistence. Instrumentation rejects dummy execution and slice +placeholder creation for reviewed cases. Proxy tests cover source identity, +resizing, incompatible partitions/dtypes, hostile caches, parent-field rebinding +and pre-fetch rejection under ambient full mode. Ruff lint/format and whitespace +checks passed. No new performance, allocation-bound or platform gate is claimed. + +## Follow-up: NumPy binary promotion, numeric casts and deferred column closure + +Added data-free binary dtype resolution for reviewed NumPy-only arithmetic and +comparison trees, including basic indexed inputs and numeric casts. Python int, +float and complex operands retain weak scalar promotion, while concrete NumPy +scalars retain their dtype. Weak integers are checked against resolved input +ranges; finite float/complex scalar overflow retains existing warning/fallback +inference rather than silently changing promotion. Blosc2 binary trees still use +existing inference: notably int32 division remains float32 there versus NumPy's +float64. Mixed/backend-changing call trees remain unreviewed, not normalized to +one universal promotion API. + +NumPy astype now binds its exact dtype/order/casting/subok/copy layout, rejects +duplicate positional/keyword options, and validates numeric output dtype and +can-cast rules without synthetic execution. Fixed-shape numeric casts preserve +shape. Flexible strings, structured/subarray casts and other incomplete output +rules retain existing inference. No streaming Blosc2 cast was registered, and +whole-array conversion is not a fallback for unsupported Blosc2 receivers. + +Column admission now checks validity and selection-mask dependencies plus the +actual cached computed LazyExpr and its input closure, not only the descriptor's +expression text and named column dependencies. Hostile cached objects reject +before dtype hooks. Remote HDF5 field admission recursively validates the records +source before synchronization; rebinding updates inherited metadata while +preserving explicitly supplied logical dtype overrides, including overrides that +initially equal the physical storage dtype. + +Verification: **11,713 passed, 55 skipped**. Differential tests cover binary dtype +pairs, broadcasting, weak/concrete scalars, division backend differences, casts +and invalid options. Instrumentation verifies reviewed metadata needs no dummy +execution. Adversarial tests cover cached column expressions, their inputs, +visibility dependencies and remote-field source rebinding. Ruff lint/format and +whitespace checks passed. + +This is not completion of binary/cast contracts or table/storage/remote audits. +Backend-changing intermediate types, remaining casts, persisted operand-type +semantics, table recipe/cache consistency, Parquet owner/dependency lifetime, +remote refresh behavior and bounded-memory execution still need review. No new +performance or cross-platform gate is claimed. + +## Follow-up: field-reference persistence and Parquet lifetime admission + +Persistence review found that NDField operands were previously written as references +to their entire structured parent, losing the field selector. The experimental +operand recipe now has an explicit `ndfield` version-1 record containing the field +name and the ordinary parent reference. Disk, frame and structured reconstruction +restore an NDField rather than an NDArray. Relative parent references support +relocation and relative source/carrier paths; missing parents retain the standard +MissingOperands diagnostic. Invalid selectors reject before resolving their parent, +reference decoding is bounded, and nested field parents reject. + +This is a new experimental operand-recipe spelling: older readers will not know +it. It does not migrate historical files that already lost their selector, alter +the parent reference's safe/full policy, or bypass legacy proxy loading gates. +NumPy-only operand persistence is already unsupported and rejects before writing +the destination; there was no silent NumPy-to-Blosc2 promotion conversion to fix. + +Parquet column admission now verifies concrete storage/discovery/cache ownership, +original storage identity, generation/closed-state checks and schema metadata +agreement before reads. Scalar Parquet-backed public Column views are also admitted +through their checked RemoteCTable storage dependency. Rebound storage, hostile +owners/caches and closed or stale handles reject before row-group reads. Variable- +length and ndarray-row columns explicitly reject until their numerical expression +adapter and row-shape semantics are reviewed; they are not treated as scalar rows. + +Verification: **11,735 passed, 55 skipped**. Added field round trips under safe and +full permission, receiver/dtype preservation, relative-path relocation, malformed +selectors, missing parents and legacy parent-policy tests. Parquet tests cover +data-free admission of raw/public scalar columns, closed/stale/changed metadata, +hostile ownership, equal-metadata storage rebinding and unsupported ndarray rows. +Ruff lint/format and whitespace checks passed. + +Remaining gates include intermediate/mixed-backend type rules, other casts and +wrapper persistence, table recipe/cache synchronization, remaining remote adapter +closures, refresh races and allocation/streaming proofs. This slice does not certify +Parquet cache contents, resource bounds, external-reference authorization or +concurrent snapshots. No new performance or cross-platform gate is claimed. + +## Local experiment assessment: remote closures, cache lifetime and differential probes + +The field/Parquet checkpoint is committed as `aa2f3372`. Checkpoint `b96cc2be` checks +RemoteArray's concrete transport, store owner, cache proxy and carrier closure +before metadata or data access. Equal-metadata source rebinding rejects; supported +standalone refresh replaces the source provenance together with its cache, and an +existing safe expression remains usable. Closed/stale handles keep their existing +diagnostics. Admission tests cover NONE/MEMORY/DISK caching, repeated evaluation, +blocked transport chunk reads and hostile metadata hooks. +These checks do not authorize external references or guarantee atomic refresh. + +Constructor review uncovered operand-dependent results retained in `cons_cache` +across evaluations. Safe evaluation now reconstructs those values each time while +retaining constant-only constructor caching. Cached constant results are admitted +again before use. A NumPy operand mutation regression covers explicit `asarray` +conversion; its simple shape rule now avoids the legacy constructor shape parser's +unsupported case. This is explicit conversion requested by the expression, not a +materializing fallback for an unsupported cast. Trusted constructor caching is +unchanged. Unregistered computed-column recipe kinds now reject explicitly. + +The deterministic differential corpus adds 48 combinations of seeded nested +expressions, float32/float64 and disk/frame/structured reconstruction. It exercises +shape/dtype, values, partial slices, NumPy ufunc composition, source value mutation +and ambient full mode with the Python text bridge disabled. Dtype comparisons use +the existing trusted backend contract, not NumPy's potentially different reduction +accumulation dtype. Another 24 forbidden-syntax variations reject before operand +resolution. Three allocation probes reject whole-source NumPy coercion and bound +Python-visible chunk reads for partial arithmetic, reductions and centering. They +are not a proof of native peak memory, every schedule or every expression family. + +Final local verification for `b96cc2be`: **11,837 passed, 55 skipped** in the +`blosc2` conda environment. Ruff lint/format and whitespace checks passed. This +is the default suite, not heavy/network or cross-platform certification. + +### Historical-control performance assessment + +Five alternating-order rounds per workload, 31 repeated evaluations per process, +one thread, 1,000 and 1,000,000 elements, float32 and float64, macOS ARM64. Control: +the same immutable pre-experiment source snapshot and matching compiled extension +used in earlier measurements. Raw artifacts are `safer-final-f64.json` and +`safer-final-f32.json` in the approved OpenCode temporary directory. These runs +precede the final RemoteArray/constructor changes; measured workloads do not use +those routes. Ratios are safe/historical; lower is faster. Family figures below +are medians of five paired process ratios, not confidence intervals. + +| 1M-element family | float64 execution ratio | float32 execution ratio | +| --- | ---: | ---: | +| Arithmetic | 0.987 | 0.996 | +| Math | 1.037 | 1.037 | +| Reduction | 1.022 | 1.027 | +| Centering | 0.922 | 1.037 | +| Axis reduction | 1.018 | 1.067 | +| Indexing | 0.986 | 0.961 | +| Persisted expression | 1.008 | 0.961 | + +The geometric mean of all paired large-array ratios is **1.003 for float64** and +**1.026 for float32**, within the provisional 5% budget for this limited matrix. +Individual rounds remain noisy (some exceed 10%); no statistical speedup or +complete family/platform gate is claimed. Tiny-array median execution ratios are +1.048–1.330 for float64 and 1.053–1.338 for float32, adding roughly **26–77 us** +and **27–71 us** respectively. Construction is generally slower, except reviewed +axis metadata; it is not hidden in execution timings. + +Peak RSS remains a failed/unresolved review gate: median paired indexing ratios +are **1.285 float64** and **1.272 float32** at 1M elements, and about **1.21** at +1,000 elements. Float32 arithmetic is **1.153**. Whole-process high-water RSS does +not locate the allocation or establish asymptotic growth, but these differences +cannot be dismissed from the small Python-visible allocation probes. + +### Verdict and remaining gates + +**The experiment works as a bounded proof of concept, not as a completed phase-1 +security certification or a production-default replacement.** It demonstrates +eval-free reconstruction/execution for admitted numerical graphs, boundary +retention across deferred work and composition, useful rejection diagnostics, +backend-specific numerical compatibility and promising large-array throughput. +Ordinary construction remains trusted; `deserialize='safe'|'full'` is retained. +No default switch or Menudet lowering is justified by these measurements. + +| Gate | Local outcome | +| --- | --- | +| Supported graph lifetime and numerical regressions | Covered by targeted and seeded tests; not exhaustive | +| Safe text bridge isolation | Instrumented on supported routes, not whole-project sandboxing | +| Metadata/signature coverage | Partial; mixed/backend-changing intermediates, weak scalars and casts remain | +| Persistence/adapters | Field/Parquet/RemoteArray slices covered; remaining wrappers and container reachability need audit | +| Table consistency | Unknown recipes reject; broader recipe/cache synchronization remains | +| Throughput | Limited large-array matrix meets geometric-mean target; tiny-expression overhead remains | +| Memory | Not passed; indexing RSS requires explanation and broader native allocation instrumentation | +| Concurrency and platforms | Refresh races, free-threaded, WASM and cross-platform safe-graph verification remain unverified | + +Finishing those gates requires additional implementation, audit and measurements; +passing the local suite cannot substitute for them. Keep this branch experimental +and phase 2 deferred. Menudet publication and compatibility freeze remain separate. + +## Follow-up assessment: release cycles, mixed contracts and native-kernel closures + +Checkpoint `e84afd70` resolves a concrete evaluation lifetime defect: the recursive +`ExpressionGraph.evaluate` visitor closed over itself, its operands and its local +array cache. Repeated evaluations therefore retained arrays until cyclic GC ran. +The evaluator now clears the cache and breaks the recursive closure in `finally`, +on both success and failure. Weak-reference regressions with cyclic GC disabled +verify that operands are released while a successful independent result remains +usable. Existing once-per-evaluation common-subexpression/reduction reuse is kept. +This is deterministic release of graph-owned references, not a general guarantee +about allocator high-water RSS or caller-retained exception tracebacks/views. + +Computed expression columns now compare descriptor and cached graph roots, operand +names and actual stored-column identities after admitting the cached dependency. +Unilateral expression/dependency/cache replacement rejects with a recipe/cache +mismatch instead of using stale numerical semantics. Supported append/delete +operations keep an existing safe graph live with current values and shape. Explicit +computed-column dtype overrides remain permitted; no universal dtype normalization +or automatic materializing rebuild was introduced. + +Added differential contracts cover 72 combinations of six nested/reduction +expressions, int32/float32/float64 and all NumPy/Blosc2 receiver pairs, plus 40 +weak-scalar cases over five dtypes and four literals. Safe/trusted values, shape, +dtype and integer-overflow outcomes agree in these cases. This extends empirical +coverage; it does not complete the mixed-intermediate static metadata rule set. +Exploratory probes also confirm existing unsupported shape-changing methods on +computed LazyExpr receivers and the trusted NumPy `.slice` rewrite limitation. +Those are not repaired by whole-array materialization or treated as parity successes. + +### Updated memory and throughput measurements + +Same historical source control, one thread, five alternating-order rounds and 31 +repeated evaluations per process. Artifacts in the approved OpenCode temporary +directory: `safer-cycle-index.json`, `safer-cycle-f32.json`, `safer-cycle-f64.json`. +No other suite/benchmark was run concurrently with the measurement workers. + +The dedicated float64 indexing scaling sweep now has median paired RSS ratios +**1.007, 1.015, 1.017 and 1.015** at 1K, 100K, 1M and 4M elements. Median execution +ratios are **1.025, 0.996, 1.008 and 1.001** respectively. The previous reproducible +indexing excess is no longer present in this matrix after the closure cleanup. +These are medians of paired ratios, not ratios of unpaired median RSS values. + +| 1M-element family | float64 execution | float32 execution | float64 RSS | float32 RSS | +| --- | ---: | ---: | ---: | ---: | +| Arithmetic | 1.064 | 1.054 | 1.142 | 0.938 | +| Math | 1.033 | 1.004 | 0.991 | 0.960 | +| Reduction | 1.015 | 1.034 | 0.992 | 1.064 | +| Centering | 1.082 | 0.976 | 1.101 | 1.065 | +| Axis reduction | 1.008 | 1.054 | 0.949 | 0.964 | +| Indexing | 0.993 | 0.992 | 0.883 | 0.978 | +| Persisted expression | 1.013 | 0.982 | 0.976 | 1.012 | + +The geometric mean over all paired 1M-element execution ratios is **1.037 float64** +and **1.018 float32**, still within the provisional 5% budget for this matrix. +Tiny-array median added latency is roughly **15–79 us float64**, **12–66 us float32**; +indexing overhead fell, but the other small-expression costs remain. No statistically +significant speedup is claimed. Whole-process RSS is still variable: the float64 +arithmetic/centering families are higher in this run, despite lower or near-equal +float32 figures. The indexing defect is explained and addressed, but a complete +native-allocation/resource-bound gate is still not passed. + +### Portable operand audit + +Checkpoint `a144fc6f` implements the following native-operand checks. + +Safe graph admission previously checked PortableLazyArray inputs without checking +its actual kernel dependency; portable computed-column caches had the same gap. +Admission now checks exact PortableKernel/native-handle types, original artifact +and handle provenance, and cached metadata against fresh native-handle metadata. +Metadata comparison rejects foreign types before equality hooks. Portable table +cached kernels must also agree with their recipe artifact. Tests cover hostile +kernel/handle/metadata objects, same-type native-handle rebinding, artifact mutation +and cached table kernel/artifact disagreement, before hooks or evaluation. + +PortableLazyArray admission also checks concrete input mappings, numeric +domain/partition extents, lane limits, context rank, cached output/grid geometry, +native input names/dtypes and broadcasting against the declared domain. Portable +column bindings/row metadata are checked before native descriptor helpers; current +stored-column dependencies and scalar row contracts are revalidated. Validated +cached artifacts reuse their owned native handle instead of recompiling during +admission. Instrumentation rejects accidental native artifact reconstruction on +first/repeated cached-column evaluations. + +Final verification: **11,973 passed, 55 skipped**, default suite in the `blosc2` +conda environment. Ruff lint/format, pre-commit checks and whitespace validation +passed. The performance workers above measured the cycle/cache checkpoint; their +ordinary numerical workloads do not exercise the subsequent portable-wrapper +checks. Native-wrapper admission overhead has not been benchmarked separately. + +This adds no Python-source reconstruction, native lowering, execution fallback or +persisted-format change. Native artifacts remain native-only. Basic portable +domain/partition/binding consistency is now covered; full wrapper/container +reachability, broader table-cache consistency, allocation bounds and concurrent +mutation guarantees remain unverified. + +### Revised verdict + +**The bounded experiment continues to work, with a materially stronger memory and +dependency-lifetime result. It remains incomplete against the full phase-1 exit +criteria.** Keep the experimental opt-in and safe/full permission distinction. +Remaining work is now: complete backend/weak-scalar/cast rule coverage and explicit +capability review; finish wrapper/container and broader table-cache audits; +profile small-expression overhead and native allocations; verify refresh/lifetime +races under the documented non-transactional contract; and certify additional +platforms, free-threaded Python, WASM and the wider benchmark matrix. Local green +tests cannot stand in for those unverified gates. No default switch, merge or +Menudet publication decision follows from this checkpoint. + +## Follow-up: intermediate reductions, containers and concurrency/platform evidence + +Implementation checkpoint: `e0c36357`. Final default-suite verification: +**12,017 passed, 55 skipped** in the `blosc2` conda environment. Ruff lint/format, +workflow YAML parsing, pre-commit checks and whitespace validation passed. + +Reviewed NumPy binary/index/cast intermediates now provide a metadata-only receiver +for reductions. This preserves NumPy-method versus Blosc2-function positional +layouts and accumulator dtype rules without constructing an array or executing a +dummy numerical operation. Direct named receivers retain their existing path. +Mixed/Blosc2-changing intermediates still defer to the existing reviewed execution +and inference where their static rule is unknown, rather than adopting NumPy's +semantics. Tests cover nested sum/mean, explicit NumPy std with ddof and cast-then-sum. +The latter two forms are checked against NumPy directly: the trusted validator or +dummy inference does not support them, so they are not called parity successes. + +The platform review identified NumPy 1.x's value-dependent scalar/0-D promotion. +Static binary dtype rules now defer those cases to backend inference on NumPy 1.x, +instead of applying NumPy 2.x's NEP 50 rules or raising an incorrect early integer +overflow. The guard branch is tested locally; actual NumPy 1.26 verification is +pending its existing CI matrix entry. Array/array dtype rules are retained. + +### Container reachability + +DictStore/TreeStore assignment of a LazyExpr failed in the size estimator because +LazyExpr has no `nbytes` property. Logical shape and normalized dtype now estimate +the storage tier without evaluating the expression. Dtype normalization also +preserves existing LazyUDF recipes that specify dtype as a string or scalar type. +No generic array conversion, operand materialization or UDF loading-policy bypass +was introduced. + +Disk/ZIP DictStore and TreeStore, plus EmbedStore, now have explicit graph-lifetime +tests under both safe/full loading permissions, including embedded and threshold- +externalized leaves. Writer instrumentation rejects expression reads/materialization; +reader instrumentation rejects the Python text bridge. Safe graphs remain safe +through partial reads and ufunc composition under ambient full mode. Malformed +expression carriers in all five container configurations reject before operand +reference resolution. This covers those leaf routes, not every heterogeneous, +recursive container/reference arrangement or crash-recovery behavior. + +### Concurrency contract and probes + +RemoteArray admission now uses the existing owner-lock then operation-lock order +to check its transport/cache closure coherently with supported refresh. Concrete +native RLocks are checked before context hooks; replaced locks reject. Refresh +already preserves its operation-lock identity while swapping source state, so no +new global lock or transactional snapshot mechanism was added. + +Controlled Event-based tests block an active safe read and overlap standalone +refresh for NONE/MEMORY/DISK caching, then verify read completion and subsequent +safe evaluation. A shared, safe-loaded expression also runs on four threads under +mixed ambient policies; composition remains safe and thread-local policy is restored. +These are deterministic ordinary-thread probes on GIL-enabled CPython, not an +exhaustive race proof or permission to mutate expression mappings/table recipes +concurrently. An evaluation may observe permitted operand changes between reads; +there is still no transactional snapshot guarantee. Native thread tests explicitly +skip on single-threaded WASM runtimes; the skip is reported, not counted as evidence. + +### Platform verification harness + +`scripts/verify_safe_lazyexpr.py` runs the bounded graph/property/container/portable +corpus without xdist and emits Python/NumPy/native versions, actual package path, +free-threaded-build and effective GIL state, test counts and skip/failure reasons. +It neither forces `PYTHON_GIL=0` nor equates a free-threaded build with no-GIL safety. +The native Linux/Windows/macOS/NumPy-1.26 workflow uploads its JSON report; wheel and +WASM/Pyodide workflows also run the harness. Those jobs are prepared, not executed +for this unpublished checkpoint. + +Local harness evidence: **710 passed, no skips**, macOS ARM64, CPython 3.14.4, +NumPy 2.5.3, C-Blosc2 3.3.5; ordinary build, GIL enabled. Artifact: +`safer-platform-local.json` in the approved OpenCode temporary directory. + +| Requested verification | Current status | +| --- | --- | +| Local numerical/metadata and container corpus | Tested; static compatibility coverage remains partial | +| Shared readonly graphs and RemoteArray read/refresh overlap | Tested with ordinary threads and three cache policies | +| Concurrent table/Parquet refresh, expression mutation and arbitrary adapter races | Not certified | +| Linux/Windows/macOS and NumPy 1.26 | CI harness wired; only local macOS/NumPy 2.x executed here | +| Free-threaded interpreter builds | Wheel harness records actual GIL fallback; external results pending | +| Actual no-GIL execution | Unsupported certification claim; never forced or inferred | +| WASM/Pyodide | Harness wired; external results pending; unavailable thread probes reported as skips | + +This advances all four requested areas but does not close the full experiment gate. +The remaining static/backend rules, complete heterogeneous reachability review, +native resource bounds and external platform/race evidence must still be reviewed. +Defaults and the existing safe/full distinction remain unchanged. + +## Follow-up: published CI, Parquet refresh and adapter/cast/resource probes + +The user pushed `85c6a077`. Native run [37831405999](https://github.com/Blosc/python-blosc2/actions/runs/37831405999) +completed successfully across Linux, Windows and macOS. The downloaded Windows +report records CPython 3.12.10, NumPy 2.5.3, C-Blosc2 3.3.5, the checkout package +path, **710 passed, no skips**, and an ordinary (not free-threaded) build. +The job labelled NumPy 1.26 actually reports **NumPy 2.5.3**: installing optional +test dependencies upgraded its runtime. That success is not NumPy 1.26 evidence. +The workflow now installs NumPy 1.26 and a compatible Zarr 3.0.x after the editable +build, then asserts the requested runtime version. Build isolation still uses +NumPy 2 headers for the dual-ABI extension. + +WASM run [37831405833](https://github.com/Blosc/python-blosc2/actions/runs/37831405833) +failed 38 tests: fixed-width accumulator/index metadata conflicted with its +32-bit NumPy fallback, one test assumed Python integers always infer int64, and +two tests assumed native complex-extrema warnings. Safe metadata now defers the +affected default integer/index rules on 32-bit WASM to existing backend inference; +explicit overrides and unaffected rules are retained. Warning tests compare the +actual backend behavior rather than requiring the native warning on every platform. +These fixes are locally tested, including a simulated guard branch, **not yet +verified by another WASM run**. Real NumPy 1.26, wheel/free-threaded and actual +no-GIL evidence remain outstanding. + +### Admission and metadata + +- Expression operand/where mappings reject unknown mapping classes and keys before + iteration/value protocols. Tests mutate a retained nested graph, rather than a + source expression that construction has already flattened. +- Concrete dtype metadata is checked before NumPy coercion. Existing string, + scalar-type and Blosc2 schema-type dtype spellings remain supported; structured + dtype keys/subdtypes are recursively checked. SimpleProxy cached shape, dtype, + chunks and blocks reject hostile replacements before comparison/iteration hooks. +- Column admission checks recipe/mapping/name and cached-live-position dependencies. + The registered persistent lazy-column mapping retains lazy loading, with explicit + owner/storage/name/source-map admission and cycle/depth bounds. This is additional + reachability coverage, not an exhaustive heterogeneous-container certification. +- Portable computed-column dtype reads use the recipe's fixed dtype rather than + evaluating all rows. A fail-on-row-evaluation probe covers both public dtype and + safe expression metadata; numerical reads still use the admitted native artifact. +- Parquet admission holds its existing concrete owner RLock while checking lifetime, + schema, coordinator/cache provenance and column geometry/dtype/spec consistency. + Replaced locks, schemas, coordinators and metadata reject before hostile hooks. + +### Supported refresh overlap + +Deterministic safe Parquet read/refresh tests now cover NONE/MEMORY/DISK caching. +They verify that refresh waits for a locked row-group read, an old graph rejects +after refresh, and a new graph evaluates correctly. The probe exposed a real race: +`LazyExpr.__getitem__` reread operand shape after a completed read, so refresh could +invalidate the handle while an independent result was being reshaped. Safe indexing +now captures admitted geometry before computation and uses it for axis removal. +If refresh interrupts another dependency read, lifetime errors remain legitimate; +this does not provide a transaction-wide snapshot or certify arbitrary concurrent +table writes, recipe/mapping mutation, Parquet source replacement or adapter races. +Thread probes explicitly skip on runtimes without Python threads. + +### Cast and resource evidence + +Added 108 NumPy cast combinations across bool, signed/unsigned integers, half/single/ +double floats and complex inputs; four destinations; and safe/same_kind/unsafe +casting. Values, metadata, TypeError behavior and warning categories match NumPy. +These are NumPy contracts, not claims of trusted-validator support or a registered +streaming Blosc2 cast implementation. + +Chunk-resource tests now instrument NDArray slicing and the exposed +`get_slice_numpy`/`decompress_chunk` bridges and assert chunk-sized source buffers. +This checks those Python-visible buffers, not all C/native temporary allocations. +The benchmark adds a 24-element partial-read family, output/input size and chunk +geometry reporting, optional fixed chunks, and constructs only the selected NumPy +reference instead of retaining all reference families. + +Three alternating-order rounds of float64 historical-control probes, 15 repetitions +per worker, produced the following median safe/control ratios with fixed 4,096-element +chunks (blocks 256): + +| Logical size | Family | Execution ratio | Whole-process peak RSS ratio | Safe peak MiB | +| --- | --- | --- | --- | --- | +| 1M | Partial (192-byte output) | 1.307 | 1.011 | 92.8 | +| 4M | Partial (192-byte output) | 1.328 | 0.995 | 152.5 | +| 1M | Reduction (8-byte output) | 1.017 | 0.988 | 98.6 | +| 4M | Reduction (8-byte output) | 0.992 | 1.000 | 183.7 | +| 1M | Center (8MB output) | 1.012 | 0.925 | 279.9 | +| 4M | Center (32MB output) | 1.002 | 0.998 | 577.5 | + +Auto-chunk probes also completed at 1K/1M/4M. These process peaks include reference +arrays, operands, outputs and backend scheduling; fixed chunks alone do not prove +constant-space native execution. Centering retains substantial whole-process RSS +in both implementations. Partial-read overhead remains measurable. No statistically +significant speedup, universal 5% budget compliance or native allocation bound is +claimed. Raw artifacts: `safer-resource-followup.json` and +`safer-resource-fixed-chunks.json` in the approved OpenCode temporary directory. + +Local default suite: **12,146 passed, 55 skipped**. Local follow-up harness: +**830 passed, no skips**, macOS ARM64, CPython 3.14.4, NumPy 2.5.3, ordinary build +with the GIL enabled. Evidence is recorded in `safer-followup-platform.json`; +Ruff lint/format, workflow YAML parsing and whitespace checks passed. +The current changes have not been pushed +or remotely verified. The experiment remains bounded and not merge-ready: remaining +backend/signature rules, exhaustive container/adapter reachability, concurrent table +mutation, native allocation bounds and actual corrected platform runs remain gates. + +## Follow-up: inline-closure preflight, nested references and table read boundaries + +Safe structured loading now checks all inline expression/portable operand recipe +closures before resolving a sibling reference. Previously, a valid outer expression +could open its first operand before discovering forbidden expression text or a +legacy UDF in another inline dependency. The preflight checks concrete mappings, +keys and recipe kinds, parses nested LazyExpr text, rejects legacy UDF dependencies, +and bounds cycles/depth. Shared acyclic recipes remain valid. Full loading permission +retains its existing behavior. This is inline **text/dependency preflight**, not +authorization of references or a claim to validate unopened external files/native +artifacts before any I/O. + +Added fail-before-reference probes for forbidden nested text, nested legacy UDFs, +cycles and excessive depth. Cross-carrier cycles are bounded for pairs of files +and DictStore members in both directory and ZIP stores. Additional mixed TreeStore +tests traverse two subtree levels, resolve shared inline graphs through same-store +member references, exercise embedded/externalized carriers and safe/full permissions, +and compose/read them under ambient full mode with the Python text bridge disabled. +These close the reviewed nested/reference routes, not every possible container +combination, concurrent archive edit, reference authorization or crash-recovery case. + +Physical and expression-computed table columns now have deterministic ordinary-thread +tests that pause before a dependency read, complete a supported public column update +in another thread, then resume the safe graph. Results observe the updated values +both in that read and subsequent evaluations; computed-expression caches do not +retain operand-dependent results. Native reads and writes deliberately do not overlap +in these probes. No synchronization/snapshot guarantee is added for simultaneous +native table mutation, append/drop operations or mutable recipe/mapping replacement. + +Another 32 NumPy cast-signature cases cover C/F/A/K order, copy/subok flags, positional +and keyword binding on negative-stride, originally Fortran-order two-dimensional +inputs, followed by a nested reduction. Shape, dtype and values follow NumPy. +LazyExpr scheduling does not acquire NumPy's aliasing/storage-order guarantees just +because an intermediate requests `copy=False`. + +Portable native-boundary probes cover elementwise and block-scalar kernels within +safe graph partial reads. Every dispatched source buffer is bounded by its unchanged +128-lane logical partition (1,024 bytes for the int64 input); temporary input/output +NumPy wrappers are released after each of four evaluations with cyclic GC disabled. +This establishes those native-call buffer sizes and Python ownership cleanup, **not +all native scratch allocations, a global RSS bound, or constant-space scheduling**. +The broader native resource gate remains open. + +The platform harness now includes the selected safe table/Parquet admission, +metadata and concurrent-read probes. Missing Parquet dependencies are collected as +a module skip rather than erroneous node-qualified selection; unavailable threads +and native descriptor support remain explicit skips, not successes. + +Local verification: **12,198 passed, 55 skipped** in the default suite; expanded +harness **901 passed, no skips**, macOS ARM64, CPython 3.14.4, NumPy 2.5.3, +C-Blosc2 3.3.5, ordinary build with GIL enabled. Report: +`safer-nested-platform.json` in the approved OpenCode temporary directory. Ruff +lint/format and whitespace checks passed. Changes remain local. Corrected WASM and +actual NumPy 1.26 runs, free-threaded/no-GIL evidence, complete heterogeneous +reachability and native allocation/resource certification remain outstanding. + +## Verified native / NumPy 1.26 / WASM checkpoint (2026-10-09) + +The pending-platform statements above describe earlier checkpoints. Runtime code +and compatibility tests at **`78ae44f9530e3b00d878956de7d0524899385424`** now pass +both workflows: + +- [Native Tests, run 37881295354](https://github.com/Blosc/python-blosc2/actions/runs/37881295354): + **success**, all five matrix jobs green, including the actual NumPy 1.26 job. +- [Tests (WASM), run 37881295353](https://github.com/Blosc/python-blosc2/actions/runs/37881295353): + **success**, built wheel tested in the Node/Pyodide runtime. + +The uploaded `safe-lazyexpr-…` JSON artifacts were downloaded and read; these are +actual runtime versions, not versions inferred from matrix labels. All report +`blosc2=4.15.0.dev0`, C-Blosc2 **3.3.5**, and `free_threaded_build=false`. + +| Runtime | Python | NumPy | Configured full CI test step (passed / skipped) | Bounded safe-graph corpus (passed / skipped) | +| --- | --- | --- | --- | --- | +| Linux x86_64, glibc 2.39 | 3.12.15 | **1.26.4** | **11,419 / 410** | **885 / 16** | +| Linux x86_64, glibc 2.39 | 3.12.15 | 2.5.3 | **12,091 / 155** | **901 / 0** | +| Linux x86_64, glibc 2.39 | 3.14.8 | 2.5.3 | **12,091 / 155** | **901 / 0** | +| macOS 26.6.2 ARM64 | 3.12.10 | 2.5.3 | **12,091 / 155** | **901 / 0** | +| Windows Server 2025 AMD64 | 3.12.10 | 2.5.3 | **12,057 / 189** | **901 / 0** | +| Emscripten 5.0.3 wasm32, Pyodide 314.0.0 | 3.14.2 | 2.4.3 | **10,078 / 782**, plus **1 XPASS** | **850 / 34** | + +“Full CI” means the workflow's configured project test selection, not every +possible marker/capability. Native main steps exclude heavy/network/TUI tests; +Linux 3.12 additionally passed the network step (**241 / 12**) and non-blocking +TUI step (**61 / 12**). WASM reported **11,923 deselected** alongside its totals. +Its existing XPASS is not a failure and is not extra safety certification. + +The NumPy 1.26 corpus's **16 skips** are exactly the unavailable NumPy +`cumulative_sum`/`cumulative_prod` API cases. Blosc2 cumulative operations still +run against equivalent legacy NumPy references. Full-suite UTF-8 feature cases +requiring NumPy >=2.0 are explicitly capability-skipped, while supported numeric +remote tests remain collected. A new NumPy 1.26 test verifies that `blosc2.utf8()` +still rejects that unsupported runtime; there is no product UTF-8 fallback. + +WASM corpus skip categories, read from `safe-lazyexpr-wasm.json`: + +- **27 individual missing-fsspec adapter tests**, plus **one Parquet module + collection skip** for missing fsspec (**28 adapter entries** total). Module-level + skip accounting does not stand in for running every selected Parquet case. +- **6 tests requiring unavailable Python threads**: three remote-refresh tests, + one shared-policy test, and two controlled table-read-boundary tests. +- **0 native-descriptor capability skips** in this selected corpus; the selected + portable kernel/native-buffer tests ran. This does not certify unselected native + capabilities or all native scratch allocations. + +Python 3.14 native/WASM JSON reports `gil_enabled_after_tests=true`. Python 3.12 +reports `null` because that runtime lacks the inspection hook; it is an ordinary, +non-free-threaded build. **No actual no-GIL run is established**, and no GIL setting +was forced to manufacture one. + +### Verification fixes and failed checkpoints + +Published scoped changes: `232d7476` (reviewed follow-ups, runtime pinning and WASM +artifact capture), `d62b4b97` (collection-skip JSON accounting), `5f3ad6be` (retain +bounded evidence after wider failures and disable matrix fail-fast), `61714ca0` +(NumPy capability-aware tests), `f98a8d16` (compatibility boundaries), and `78ae44f9` +(preserve Blosc2 index dtype). Parent checkpoint `a8449aef`'s caller-serialized +table-threading probes is also included in the final verified revision. + +- The old “NumPy 1.26” checkpoint actually used NumPy 2.5.3. Runtime pinning now + happens **after** editable build/test dependency installation and is asserted; + NumPy 1.26 uses compatible Zarr **3.1.5** rather than the older 3.0 API. +- [Run 37877855457](https://github.com/Blosc/python-blosc2/actions/runs/37877855457) + proved NumPy 1.26.4 but failed unsupported UTF-8 collection and other runtime + assumptions. Lazy rich-schema construction and per-feature skips corrected + collection without dropping numeric modules; arithmetic promotion now compares + against the installed NumPy's real contract rather than imposing NumPy 2 rules. +- WASM's original 38 failures narrowed to four positional index cases. Returning + `None` for index metadata did **not** establish the assumed NumPy index contract; + an overly broad platform-index rule then produced 14 real-backend mismatches in + [run 37879891856](https://github.com/Blosc/python-blosc2/actions/runs/37879891856). + Final tests compare the actual receiver backend: Blosc2 retains `DEFAULT_INDEX` + (int64), while NumPy indices are platform-sized. Only the small-integer WASM + sum/product/cumulative accumulator rule uses signed/unsigned NumPy platform + widths. Numerical backend semantics were not changed to satisfy test references. +- Zarr's older `WrapperStore` lacked read-only cloning; the traffic wrapper now + explicitly delegates cloning while retaining accounting. A Windows internal + null-predicate comparison could become a bool during identity-equality mode; + it now constructs the lazy comparison directly, with both flag states tested. + +Local scoped checks during these fixes passed **1,593 tests / 1 capability skip**, +then **1,057 tests**, then **814 expression-graph tests**; all Python/test commands +used the `blosc2` conda environment. Scoped pre-commit lint/format/YAML checks passed. +Raw downloaded artifacts and CI logs are retained under the approved OpenCode +temporary directory in `safer-artifacts-78ae44f9` and +`safer-wasm-artifacts-78ae44f9`. + +These green runs close the corrected native/NumPy 1.26/WASM checkpoint gate only. +They **do not finish the experiment or make it merge-ready**. Complete heterogeneous +container/adapter reachability, remaining backend/signature rules, actual no-GIL +behavior, and native allocation/resource certification remain open. Unprotected +native table read/write overlap remains unsupported; caller serialization is +required. Ordinary defaults, safe/full loading distinctions, and Menudet semantics +remain unchanged. No universal allocation bound or constant-space guarantee is +claimed. diff --git a/plans/safer-lazyexpr-table-concurrency.md b/plans/safer-lazyexpr-table-concurrency.md new file mode 100644 index 000000000..29b711f32 --- /dev/null +++ b/plans/safer-lazyexpr-table-concurrency.md @@ -0,0 +1,124 @@ +# Native CTable read/write overlap + +## Contract and scope + +Unprotected threaded reads overlapping mutation of the same underlying CTable +are unsupported. Safe expression execution is not storage synchronization or a +transactional snapshot. Use one caller-owned lock around complete operations, +including expression evaluation, writes, append, close, and access through views +or column handles. This changes documentation only, not trusted defaults, +numerical behavior, lifetime provenance, or scheduling. + +No automatic table lock was added: doing that correctly requires covering +visibility/null sidecars, computed dependencies, index state, aliases, raw native +handles, and multi-column mutations, not just Column._values_from_key. A lock +around individual native reads would not give an expression-wide snapshot. + +## Existing mechanisms and concrete hazards + +- `doc/guides/sharing_across_processes.md` documents separate persistent handles, + SWMR, and advisory sidecar locking. It does not promise same-handle CTable + thread safety; CTable metadata and multi-column writes are not transactions. +- `NDArray.get_slice_numpy` in `src/blosc2/blosc2_ext.pyx` acquires a per-array + reader lock (shared by extension views). `set_slice`, orthogonal writes, and + `resize` do not acquire it. Span reads use independent decompression contexts; + that does not protect underlying chunk ownership from a writer. +- Native reads can borrow compressed chunk pointers; native chunk replacement + can free old buffers. Inspection of locally built C-Blosc2 sources + (`build_py314/_deps/blosc2-src/blosc/schunk.c`, get/decompress/update chunk) + establishes a potential buffer-lifetime hazard, not an observed sanitizer + failure. Shared mutable decompression context/cache state is another hazard + when a partial update decompresses the same chunk during a suspended read. +- Append calls `_grow`, resizes stored columns and validity arrays separately, + writes values, then publishes row visibility/count. A reader can have cached + bounds or dependencies from before that sequence. GIL retention during a + native call is not sufficient: a Python callback can release it by waiting. + +## Deterministic bounded probes + +`tests/ctable/test_ctable_concurrency.py` pauses inside an identity Python +postfilter invoked by native decompression, after entering the native read and +copying one block. This is **overlapping native call lifetimes**, not a pause +before native access, and not a claim that two native CPU instructions execute +at the same instant. Ordinary GIL-enabled Python only; no `set_releasegil`, +free-threaded Python, uncontrolled stress, or timing-based scheduling assertions. + +The writer uses public `table["x"][0] = 91` (same first chunk) or `table.append` +(capacity is filled beforehand, and growth of the same raw array is asserted). +Events have ten-second bounds; futures have timeouts and resume in `finally`. +All pytest variants run in isolated subprocesses with a 45-second outer timeout, +so a native crash or executor shutdown deadlock cannot crash or hang pytest. +The postfilter is removed and the table closed after workers finish. + +Default tests cover caller serialization for safe/full and overwrite/append. +A nonblocking lock acquisition proves writer contention while the read is live; +the reader finishes with old values, then the public write completes and a fresh +graph sees the updated values. They do **not** claim simultaneous unprotected +native access is safe. + +The explicit CLI `MODE MUTATION unsafe` enables the unsupported investigation +probe. Invoke it only from a disposable, timeout-controlled subprocess, e.g.: + +```python +subprocess.run( + [ + sys.executable, + "-X", + "faulthandler", + "tests/ctable/test_ctable_concurrency.py", + "safe", + "overwrite", + "unsafe", + ], + capture_output=True, + text=True, + timeout=25, +) +``` + +Observed in bounded diagnostic invocations on macOS ARM64, Python 3.14.4, NumPy 2.5.3, +C-Blosc2 3.3.5: safe/full × overwrite/append all printed +`WRITE_COMPLETED_INSIDE_NATIVE_READ` and exited 0. Reads returned 64 rows; +append left 65 rows. No native crash or deadlock was observed. **Overwrite +produced numerical corruption in both modes**: the first `x * 2` value was 48, +neither the before value 0 nor the after value 182 (`x[0] = 91`). The complete +read matched neither before nor after; a fresh graph after worker completion +read the correct updated data. This is an observed incorrect read, not merely +nontransactional freshness. It is consistent with reentrant native context or +buffer/cache interference, but no sanitizer diagnosis identifies the exact +mechanism. Append returned the old 64-row prefix correctly in these probes; +this is not evidence of general append/resize safety. The results establish no +memory-safety guarantee, historical full-mode parity, or transactional contract. +Native computed-column execution may bypass a source +postfilter, so these probes deliberately test direct stored Column graphs, not +claim coverage of every computed/native engine path. Full-mode graphs can retain +pre-append shape; post-write checks use a fresh graph to preserve that contract. + +## Verification + +- Focused new tests plus existing computed-column tests: 120 passed. +- Ruff lint and formatting checks passed for the new test and `ctable.py`. +- `git diff --check` passed. +- Full default local suite: 12,202 passed, 56 skipped (exit 0), warnings-as-errors + and default marker exclusions unchanged, 31.54 seconds in final pytest run. +- HEAD before/after: `61714ca0a0f1d0631a2960ab7b782f6e12f1c46d`. + SHA-256 snapshot of all tracked file contents, the new concurrency test, and + native extension `.so` files was identical before/after the full run. Snapshot + aggregate digest: + `89d0d7c61373df77c4c5836fc521069975bf6ad443d8af8239e4f9902d96a8b7`. + This working tree includes the CTable contract docstring and new test, not + merely the HEAD tree. Only this untracked findings document was finalized + afterward; tested source/test contents were unchanged. +- Logs/manifest/probe reports are under the approved temporary directory: + `/private/var/folders/tb/7hwq2y354bb_68xwxjwjwwlr0000gn/T/opencode/`, named + `table-concurrency-full-pytest.log`, + `table-concurrency-full-pytest-verification.json`, + `table-concurrency-full-pytest-tree.json`, and + `table-concurrency-native-probes.json`. + +No commits or pushes, no CI/workflow/compatibility-gating edits, no automatic +locking/snapshot changes. Architectural blocker: safely supporting unprotected +native table overlap requires a stable shared storage/operation-lock design +covering every alias and mutation path; a safe-expression-only patch is +insufficient. Caller serialization is the bounded recommendation implemented +and tested here. diff --git a/pyproject.toml b/pyproject.toml index 07664b095..cc18f3b1b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -35,13 +35,12 @@ dependencies = [ "numpy>=1.26", "ndindex", "msgpack", - "numexpr>=2.14.1; platform_machine != 'wasm32'", "pydantic", "httpx[http2]", "rich", "threadpoolctl; platform_machine != 'wasm32'", ] -version = "4.14.2.dev0" +version = "4.15.0.dev0" [project.entry-points."array_api"] blosc2 = "blosc2" diff --git a/pytest.ini b/pytest.ini index f566db577..9631a5292 100644 --- a/pytest.ini +++ b/pytest.ini @@ -29,6 +29,7 @@ testpaths = src/blosc2/schunk.py markers = + native_semantics: exhaustive native numerical/backend reference tests; opt in with --native-semantics. heavy: tests that take long time to complete. network: tests that require real network sockets, including localhost HTTP/S3 servers. tui: b2view Textual UI tests; each one boots a headless app session. @@ -38,3 +39,7 @@ markers = filterwarnings = error ignore::UserWarning + # Free-threaded CPython safely enables the GIL for this extension. This is + # an expected import notification, not a claim that no-GIL execution is safe. + # Keep the regex here: pytest's command-line -W treats the message literally. + ignore:The global interpreter lock \(GIL\) has been enabled to load module 'blosc2\.blosc2_ext':RuntimeWarning diff --git a/scripts/certify_menudet_math.py b/scripts/certify_menudet_math.py new file mode 100644 index 000000000..0a193a743 --- /dev/null +++ b/scripts/certify_menudet_math.py @@ -0,0 +1,176 @@ +"""Bounded, independent Menudet math certification (not a universal libm bound). + +Normal checks need only installed blosc2 and NumPy. Regeneration additionally +needs mpmath; references must agree at 100 and 200 decimal digits. Checked-in +vectors store exact input/output encodings, with per-function ULP budgets. +Run from any directory: python scripts/certify_menudet_math.py +""" + +import argparse +import json +import platform +from pathlib import Path + +import numpy as np + +DATA = Path(__file__).resolve().with_name("menudet_math_vectors.json") + + +def reference_cases(mp): + """Finite representative domains, including endpoints and cancellation.""" + unary = { + "acos": (-1, -0.75, 0.125, 0.875, 1), + "acosh": (1, 1.0009765625, 1.5, 8), + "asin": (-1, -0.75, 0.125, 0.875, 1), + "asinh": (-8, -0.125, 0.0009765625, 2), + "atan": (-8, -0.125, 0.0009765625, 2), + "atanh": (-0.875, -0.125, 0.0009765625, 0.875), + "cbrt": (-8, -0.125, 0.25, 2), + "cos": (-8, -0.125, 0.0009765625, 2), + "cosh": (-8, -0.125, 0.0009765625, 2), + "cospi": (-2, -0.75, 0.125, 0.5), + "erf": (-4, -0.125, 0.0009765625, 2), + "erfc": (-4, -0.125, 0.0009765625, 2), + "exp": (-8, -0.125, 0.0009765625, 2), + "exp10": (-8, -0.125, 0.0009765625, 2), + "exp2": (-8, -0.125, 0.0009765625, 2), + "expm1": (-8, -0.125, 0.0009765625, 2), + "lgamma": (0.125, 0.75, 1.5, 8), + "log": (0.0009765625, 0.75, 1.0009765625, 8), + "log10": (0.0009765625, 0.75, 1.0009765625, 8), + "log1p": (-0.875, -0.125, 0.0009765625, 8), + "log2": (0.0009765625, 0.75, 1.0009765625, 8), + "sin": (-8, -0.125, 0.0009765625, 2), + "sinh": (-8, -0.125, 0.0009765625, 2), + "sinpi": (-2, -0.75, 0.125, 0.5), + "sqrt": (0, 0.125, 1.0009765625, 8), + "tan": (-8, -0.125, 0.0009765625, 2), + "tanh": (-8, -0.125, 0.0009765625, 2), + "tgamma": (0.125, 0.75, 1.5, 8), + } + special = { + "cbrt": lambda x: mp.sign(x) * mp.root(abs(x), 3), + "cospi": mp.cospi, + "exp10": lambda x: mp.power(10, x), + "exp2": lambda x: mp.power(2, x), + "lgamma": lambda x: mp.log(abs(mp.gamma(x))), + "log10": lambda x: mp.log(x, 10), + "log2": lambda x: mp.log(x, 2), + "sinpi": mp.sinpi, + "tgamma": mp.gamma, + } + budgets = {"cospi": 8, "sinpi": 8, "exp10": 8, "lgamma": 8, "tgamma": 8} + for name, inputs in unary.items(): + function = special[name] if name in special else getattr(mp, name) + yield name, function, [(x,) for x in inputs], budgets.get(name, 4) + binary = { + "atan2": (mp.atan2, [(-2, -3), (0.125, -8), (2, 3)], 4), + "hypot": (lambda x, y: mp.sqrt(x * x + y * y), [(3, 4), (0.125, 8), (2, 3)], 4), + "logaddexp": (lambda x, y: mp.log(mp.exp(x) + mp.exp(y)), [(-8, -8), (-8, 8), (0.125, 0.25)], 8), + "pow": (mp.power, [(0.125, 1.5), (2, -0.75), (8, 0.125)], 4), + "fdim": (lambda x, y: max(x - y, mp.mpf(0)), [(8, 0.125), (0.125, 8)], 0), + "fmin": (min, [(-8, 0.125), (0.125, 8)], 0), + "fmax": (max, [(-8, 0.125), (0.125, 8)], 0), + "copysign": (lambda x, y: abs(x) * mp.sign(y), [(0.125, -8), (-8, 0.125)], 0), + "fmod": (lambda x, y: x - int(x / y) * y, [(-8.125, 2), (8.125, 2)], 0), + # Menudet 1.0 remainder follows floor division (divisor sign), not + # the legacy IEEE remainder operation's nearest-integer quotient. + "remainder": (lambda x, y: x - mp.floor(x / y) * y, [(-7, 2), (7, 2), (-7, -2), (7, -2)], 0), + "ldexp": (lambda x, y: x * mp.power(2, int(y)), [(0.125, -8), (1.5, 8)], 0), + "fma": (lambda x, y, z: x * y + z, [(1.0009765625, 0.9990234375, -1), (0.125, 8, -0.75)], 0), + } + for name, (function, inputs, budget) in binary.items(): + yield name, function, inputs, budget + + +def generate(): + import mpmath as mp + + cases = [] + for name, function, inputs, budget in reference_cases(mp): + for dtype in ("float32", "float64"): + for args in inputs: + typed = [float(np.asarray(x, dtype=dtype)) for x in args] + results = [] + for precision in (100, 200): + with mp.workdps(precision): + result = function(*(mp.mpf(x) for x in typed)) + results.append(float(np.asarray(float(result), dtype=dtype)).hex()) + if results[0] != results[1]: + raise ValueError(f"Unstable reference: {name} {dtype} {typed}") + cases.append( + { + "function": name, + "dtype": dtype, + "inputs": [x.hex() for x in typed], + "expected": results[0], + "max_ulp": budget, + } + ) + return { + "generator": f"mpmath {mp.__version__}, 100/200 decimal digits", + "scope": "Finite inputs only; not a global accuracy or bitwise portability guarantee", + "cases": cases, + } + + +def check(record): + import blosc2 + + failures = [] + maxima = {} + for case in record["cases"]: + name, dtype = case["function"], case["dtype"] + names = list("xyz"[: len(case["inputs"])]) + signature = dict.fromkeys(names, dtype) + if name == "ldexp": + signature["y"] = "int64" + source = f"def k({', '.join(names)}):\n return {name}({', '.join(names)})\n" + artifact = blosc2.DSLKernel.from_source(source).export(signature, dtype) + kernel = blosc2.PortableKernel.from_json(artifact, jit=False) + inputs = { + key: np.array([float.fromhex(value)], dtype=signature[key]) + for key, value in zip(names, case["inputs"], strict=True) + } + actual = float(kernel.evaluate(inputs)[0]) + expected = float.fromhex(case["expected"]) + # Use the smaller adjacent-format gap, including at powers of two. Python + # doubles represent all tested f32/f64 gaps/differences exactly enough here. + ref = np.asarray(expected, dtype=dtype) + upper = float(np.nextafter(ref, np.asarray(np.inf, dtype=dtype))) + lower = float(np.nextafter(ref, np.asarray(-np.inf, dtype=dtype))) + gap = min(upper - expected, expected - lower) + error = abs(actual - expected) / gap + key = f"{name}/{dtype}" + maxima[key] = max(maxima.get(key, 0), error) + if not np.isfinite(actual) or error > case["max_ulp"]: + failures.append({**case, "actual": actual.hex(), "error_ulp": error}) + return { + "package": blosc2.__file__, + "version": blosc2.__version__, + "platform": platform.platform(), + "reference": record["generator"], + "samples": len(record["cases"]), + "max_observed_ulp": maxima, + "failures": failures, + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--generate", action="store_true", help="regenerate independent reference vectors") + parser.add_argument("--report", type=Path, help="write machine-readable certification report") + args = parser.parse_args() + if args.generate: + DATA.write_text(json.dumps(generate(), indent=2) + "\n") + return + report = check(json.loads(DATA.read_text())) + if args.report: + args.report.write_text(json.dumps(report, indent=2) + "\n") + print(json.dumps(report, indent=2)) + if report["failures"]: + raise SystemExit(1) + + +if __name__ == "__main__": + main() diff --git a/scripts/menudet_math_vectors.json b/scripts/menudet_math_vectors.json new file mode 100644 index 000000000..9306b9333 --- /dev/null +++ b/scripts/menudet_math_vectors.json @@ -0,0 +1,2662 @@ +{ + "generator": "mpmath 1.3.0, 100/200 decimal digits", + "scope": "Finite inputs only; not a global accuracy or bitwise portability guarantee", + "cases": [ + { + "function": "acos", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+0" + ], + "expected": "0x1.921fb60000000p+1", + "max_ulp": 4 + }, + { + "function": "acos", + "dtype": "float32", + "inputs": [ + "-0x1.8000000000000p-1" + ], + "expected": "0x1.359d260000000p+1", + "max_ulp": 4 + }, + { + "function": "acos", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3" + ], + "expected": "0x1.720a3a0000000p+0", + "max_ulp": 4 + }, + { + "function": "acos", + "dtype": "float32", + "inputs": [ + "0x1.c000000000000p-1" + ], + "expected": "0x1.02be9c0000000p-1", + "max_ulp": 4 + }, + { + "function": "acos", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+0" + ], + "expected": "0x0.0p+0", + "max_ulp": 4 + }, + { + "function": "acos", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+0" + ], + "expected": "0x1.921fb54442d18p+1", + "max_ulp": 4 + }, + { + "function": "acos", + "dtype": "float64", + "inputs": [ + "-0x1.8000000000000p-1" + ], + "expected": "0x1.359d26f93b6c3p+1", + "max_ulp": 4 + }, + { + "function": "acos", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3" + ], + "expected": "0x1.720a392c1d955p+0", + "max_ulp": 4 + }, + { + "function": "acos", + "dtype": "float64", + "inputs": [ + "0x1.c000000000000p-1" + ], + "expected": "0x1.02be9ce0b87cdp-1", + "max_ulp": 4 + }, + { + "function": "acos", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+0" + ], + "expected": "0x0.0p+0", + "max_ulp": 4 + }, + { + "function": "acosh", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+0" + ], + "expected": "0x0.0p+0", + "max_ulp": 4 + }, + { + "function": "acosh", + "dtype": "float32", + "inputs": [ + "0x1.0040000000000p+0" + ], + "expected": "0x1.6a025c0000000p-5", + "max_ulp": 4 + }, + { + "function": "acosh", + "dtype": "float32", + "inputs": [ + "0x1.8000000000000p+0" + ], + "expected": "0x1.ecc2ca0000000p-1", + "max_ulp": 4 + }, + { + "function": "acosh", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.62636e0000000p+1", + "max_ulp": 4 + }, + { + "function": "acosh", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+0" + ], + "expected": "0x0.0p+0", + "max_ulp": 4 + }, + { + "function": "acosh", + "dtype": "float64", + "inputs": [ + "0x1.0040000000000p+0" + ], + "expected": "0x1.6a025bf510baep-5", + "max_ulp": 4 + }, + { + "function": "acosh", + "dtype": "float64", + "inputs": [ + "0x1.8000000000000p+0" + ], + "expected": "0x1.ecc2caec5160ap-1", + "max_ulp": 4 + }, + { + "function": "acosh", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.62636e408c33bp+1", + "max_ulp": 4 + }, + { + "function": "asin", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+0" + ], + "expected": "-0x1.921fb60000000p+0", + "max_ulp": 4 + }, + { + "function": "asin", + "dtype": "float32", + "inputs": [ + "-0x1.8000000000000p-1" + ], + "expected": "-0x1.b235320000000p-1", + "max_ulp": 4 + }, + { + "function": "asin", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3" + ], + "expected": "0x1.00abe00000000p-3", + "max_ulp": 4 + }, + { + "function": "asin", + "dtype": "float32", + "inputs": [ + "0x1.c000000000000p-1" + ], + "expected": "0x1.10c0660000000p+0", + "max_ulp": 4 + }, + { + "function": "asin", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+0" + ], + "expected": "0x1.921fb60000000p+0", + "max_ulp": 4 + }, + { + "function": "asin", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+0" + ], + "expected": "-0x1.921fb54442d18p+0", + "max_ulp": 4 + }, + { + "function": "asin", + "dtype": "float64", + "inputs": [ + "-0x1.8000000000000p-1" + ], + "expected": "-0x1.b235315c680dcp-1", + "max_ulp": 4 + }, + { + "function": "asin", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3" + ], + "expected": "0x1.00abe0c129e1ep-3", + "max_ulp": 4 + }, + { + "function": "asin", + "dtype": "float64", + "inputs": [ + "0x1.c000000000000p-1" + ], + "expected": "0x1.10c066d3e6932p+0", + "max_ulp": 4 + }, + { + "function": "asin", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+0" + ], + "expected": "0x1.921fb54442d18p+0", + "max_ulp": 4 + }, + { + "function": "asinh", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.6363720000000p+1", + "max_ulp": 4 + }, + { + "function": "asinh", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.fead0c0000000p-4", + "max_ulp": 4 + }, + { + "function": "asinh", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.fffffa0000000p-11", + "max_ulp": 4 + }, + { + "function": "asinh", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.7192180000000p+0", + "max_ulp": 4 + }, + { + "function": "asinh", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.63637195fabd3p+1", + "max_ulp": 4 + }, + { + "function": "asinh", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.fead0b6996973p-4", + "max_ulp": 4 + }, + { + "function": "asinh", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.fffffaaaaad11p-11", + "max_ulp": 4 + }, + { + "function": "asinh", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.719218313d087p+0", + "max_ulp": 4 + }, + { + "function": "atan", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.7249fa0000000p+0", + "max_ulp": 4 + }, + { + "function": "atan", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.fd5baa0000000p-4", + "max_ulp": 4 + }, + { + "function": "atan", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.fffff60000000p-11", + "max_ulp": 4 + }, + { + "function": "atan", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.1b6e1a0000000p+0", + "max_ulp": 4 + }, + { + "function": "atan", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.7249faa996a21p+0", + "max_ulp": 4 + }, + { + "function": "atan", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.fd5ba9aac2f6ep-4", + "max_ulp": 4 + }, + { + "function": "atan", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.fffff55555bbcp-11", + "max_ulp": 4 + }, + { + "function": "atan", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.1b6e192ebbe44p+0", + "max_ulp": 4 + }, + { + "function": "atanh", + "dtype": "float32", + "inputs": [ + "-0x1.c000000000000p-1" + ], + "expected": "-0x1.5aa1640000000p+0", + "max_ulp": 4 + }, + { + "function": "atanh", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.0158920000000p-3", + "max_ulp": 4 + }, + { + "function": "atanh", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.0000060000000p-10", + "max_ulp": 4 + }, + { + "function": "atanh", + "dtype": "float32", + "inputs": [ + "0x1.c000000000000p-1" + ], + "expected": "0x1.5aa1640000000p+0", + "max_ulp": 4 + }, + { + "function": "atanh", + "dtype": "float64", + "inputs": [ + "-0x1.c000000000000p-1" + ], + "expected": "-0x1.5aa16394d481fp+0", + "max_ulp": 4 + }, + { + "function": "atanh", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.015891c9eaef7p-3", + "max_ulp": 4 + }, + { + "function": "atanh", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.0000055555889p-10", + "max_ulp": 4 + }, + { + "function": "atanh", + "dtype": "float64", + "inputs": [ + "0x1.c000000000000p-1" + ], + "expected": "0x1.5aa16394d481fp+0", + "max_ulp": 4 + }, + { + "function": "cbrt", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.0000000000000p+1", + "max_ulp": 4 + }, + { + "function": "cbrt", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.0000000000000p-1", + "max_ulp": 4 + }, + { + "function": "cbrt", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-2" + ], + "expected": "0x1.428a300000000p-1", + "max_ulp": 4 + }, + { + "function": "cbrt", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.428a300000000p+0", + "max_ulp": 4 + }, + { + "function": "cbrt", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.0000000000000p+1", + "max_ulp": 4 + }, + { + "function": "cbrt", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.0000000000000p-1", + "max_ulp": 4 + }, + { + "function": "cbrt", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-2" + ], + "expected": "0x1.428a2f98d728bp-1", + "max_ulp": 4 + }, + { + "function": "cbrt", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.428a2f98d728bp+0", + "max_ulp": 4 + }, + { + "function": "cos", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.29fbec0000000p-3", + "max_ulp": 4 + }, + { + "function": "cos", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "0x1.fc01560000000p-1", + "max_ulp": 4 + }, + { + "function": "cos", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.fffff00000000p-1", + "max_ulp": 4 + }, + { + "function": "cos", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "-0x1.aa22660000000p-2", + "max_ulp": 4 + }, + { + "function": "cos", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.29fbebf632f94p-3", + "max_ulp": 4 + }, + { + "function": "cos", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "0x1.fc015527d5bd3p-1", + "max_ulp": 4 + }, + { + "function": "cos", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.fffff00000155p-1", + "max_ulp": 4 + }, + { + "function": "cos", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "-0x1.aa22657537205p-2", + "max_ulp": 4 + }, + { + "function": "cosh", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "0x1.749eaa0000000p+10", + "max_ulp": 4 + }, + { + "function": "cosh", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "0x1.0200aa0000000p+0", + "max_ulp": 4 + }, + { + "function": "cosh", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.0000080000000p+0", + "max_ulp": 4 + }, + { + "function": "cosh", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.e18fa00000000p+1", + "max_ulp": 4 + }, + { + "function": "cosh", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "0x1.749eaa93f4e76p+10", + "max_ulp": 4 + }, + { + "function": "cosh", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "0x1.0200aac16db6fp+0", + "max_ulp": 4 + }, + { + "function": "cosh", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.00000800000abp+0", + "max_ulp": 4 + }, + { + "function": "cosh", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.e18fa0df2d9bcp+1", + "max_ulp": 4 + }, + { + "function": "cospi", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+1" + ], + "expected": "0x1.0000000000000p+0", + "max_ulp": 8 + }, + { + "function": "cospi", + "dtype": "float32", + "inputs": [ + "-0x1.8000000000000p-1" + ], + "expected": "-0x1.6a09e60000000p-1", + "max_ulp": 8 + }, + { + "function": "cospi", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3" + ], + "expected": "0x1.d906bc0000000p-1", + "max_ulp": 8 + }, + { + "function": "cospi", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-1" + ], + "expected": "0x0.0p+0", + "max_ulp": 8 + }, + { + "function": "cospi", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+1" + ], + "expected": "0x1.0000000000000p+0", + "max_ulp": 8 + }, + { + "function": "cospi", + "dtype": "float64", + "inputs": [ + "-0x1.8000000000000p-1" + ], + "expected": "-0x1.6a09e667f3bcdp-1", + "max_ulp": 8 + }, + { + "function": "cospi", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3" + ], + "expected": "0x1.d906bcf328d46p-1", + "max_ulp": 8 + }, + { + "function": "cospi", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-1" + ], + "expected": "0x0.0p+0", + "max_ulp": 8 + }, + { + "function": "erf", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+2" + ], + "expected": "-0x1.0000000000000p+0", + "max_ulp": 4 + }, + { + "function": "erf", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.1f5e1a0000000p-3", + "max_ulp": 4 + }, + { + "function": "erf", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.20dd6e0000000p-10", + "max_ulp": 4 + }, + { + "function": "erf", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.fd9ae20000000p-1", + "max_ulp": 4 + }, + { + "function": "erf", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+2" + ], + "expected": "-0x1.ffffff7b91176p-1", + "max_ulp": 4 + }, + { + "function": "erf", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.1f5e1a35c3b89p-3", + "max_ulp": 4 + }, + { + "function": "erf", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.20dd6eff8cb8fp-10", + "max_ulp": 4 + }, + { + "function": "erf", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.fd9ae142795e3p-1", + "max_ulp": 4 + }, + { + "function": "erfc", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+2" + ], + "expected": "0x1.0000000000000p+1", + "max_ulp": 4 + }, + { + "function": "erfc", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "0x1.23ebc40000000p+0", + "max_ulp": 4 + }, + { + "function": "erfc", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.ff6f920000000p-1", + "max_ulp": 4 + }, + { + "function": "erfc", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.328f5e0000000p-8", + "max_ulp": 4 + }, + { + "function": "erfc", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+2" + ], + "expected": "0x1.ffffffbdc88bbp+0", + "max_ulp": 4 + }, + { + "function": "erfc", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "0x1.23ebc346b8771p+0", + "max_ulp": 4 + }, + { + "function": "erfc", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.ff6f91488039ap-1", + "max_ulp": 4 + }, + { + "function": "erfc", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.328f5ec350e67p-8", + "max_ulp": 4 + }, + { + "function": "exp", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "0x1.5fc2100000000p-12", + "max_ulp": 4 + }, + { + "function": "exp", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "0x1.c3d6a20000000p-1", + "max_ulp": 4 + }, + { + "function": "exp", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.0040080000000p+0", + "max_ulp": 4 + }, + { + "function": "exp", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.d8e64c0000000p+2", + "max_ulp": 4 + }, + { + "function": "exp", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "0x1.5fc21041027adp-12", + "max_ulp": 4 + }, + { + "function": "exp", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "0x1.c3d6a24ed8222p-1", + "max_ulp": 4 + }, + { + "function": "exp", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.00400800aab55p+0", + "max_ulp": 4 + }, + { + "function": "exp", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.d8e64b8d4ddaep+2", + "max_ulp": 4 + }, + { + "function": "exp10", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "0x1.5798ee0000000p-27", + "max_ulp": 8 + }, + { + "function": "exp10", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "0x1.7ff2220000000p-1", + "max_ulp": 8 + }, + { + "function": "exp10", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.0093880000000p+0", + "max_ulp": 8 + }, + { + "function": "exp10", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.9000000000000p+6", + "max_ulp": 8 + }, + { + "function": "exp10", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "0x1.5798ee2308c3ap-27", + "max_ulp": 8 + }, + { + "function": "exp10", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "0x1.7ff2224115d9ap-1", + "max_ulp": 8 + }, + { + "function": "exp10", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.009388004be7ep+0", + "max_ulp": 8 + }, + { + "function": "exp10", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.9000000000000p+6", + "max_ulp": 8 + }, + { + "function": "exp2", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "0x1.0000000000000p-8", + "max_ulp": 4 + }, + { + "function": "exp2", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "0x1.d5818e0000000p-1", + "max_ulp": 4 + }, + { + "function": "exp2", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.002c600000000p+0", + "max_ulp": 4 + }, + { + "function": "exp2", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.0000000000000p+2", + "max_ulp": 4 + }, + { + "function": "exp2", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "0x1.0000000000000p-8", + "max_ulp": 4 + }, + { + "function": "exp2", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "0x1.d5818dcfba487p-1", + "max_ulp": 4 + }, + { + "function": "exp2", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.002c605e2e8cfp+0", + "max_ulp": 4 + }, + { + "function": "exp2", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.0000000000000p+2", + "max_ulp": 4 + }, + { + "function": "expm1", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.ffd4080000000p-1", + "max_ulp": 4 + }, + { + "function": "expm1", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.e14aee0000000p-4", + "max_ulp": 4 + }, + { + "function": "expm1", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.0020020000000p-10", + "max_ulp": 4 + }, + { + "function": "expm1", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.98e64c0000000p+2", + "max_ulp": 4 + }, + { + "function": "expm1", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.ffd407bdf7dfbp-1", + "max_ulp": 4 + }, + { + "function": "expm1", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.e14aed893eef4p-4", + "max_ulp": 4 + }, + { + "function": "expm1", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.002002aad5577p-10", + "max_ulp": 4 + }, + { + "function": "expm1", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.98e64b8d4ddaep+2", + "max_ulp": 4 + }, + { + "function": "lgamma", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3" + ], + "expected": "0x1.027c4c0000000p+1", + "max_ulp": 8 + }, + { + "function": "lgamma", + "dtype": "float32", + "inputs": [ + "0x1.8000000000000p-1" + ], + "expected": "0x1.a051c40000000p-3", + "max_ulp": 8 + }, + { + "function": "lgamma", + "dtype": "float32", + "inputs": [ + "0x1.8000000000000p+0" + ], + "expected": "-0x1.eeb95c0000000p-4", + "max_ulp": 8 + }, + { + "function": "lgamma", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.10ce200000000p+3", + "max_ulp": 8 + }, + { + "function": "lgamma", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3" + ], + "expected": "0x1.027c4cfd515b0p+1", + "max_ulp": 8 + }, + { + "function": "lgamma", + "dtype": "float64", + "inputs": [ + "0x1.8000000000000p-1" + ], + "expected": "0x1.a051c372609eep-3", + "max_ulp": 8 + }, + { + "function": "lgamma", + "dtype": "float64", + "inputs": [ + "0x1.8000000000000p+0" + ], + "expected": "-0x1.eeb95b094c191p-4", + "max_ulp": 8 + }, + { + "function": "lgamma", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.10ce1f32dcc30p+3", + "max_ulp": 8 + }, + { + "function": "log", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "-0x1.bb9d3c0000000p+2", + "max_ulp": 4 + }, + { + "function": "log", + "dtype": "float32", + "inputs": [ + "0x1.8000000000000p-1" + ], + "expected": "-0x1.2696220000000p-2", + "max_ulp": 4 + }, + { + "function": "log", + "dtype": "float32", + "inputs": [ + "0x1.0040000000000p+0" + ], + "expected": "0x1.ffc00a0000000p-11", + "max_ulp": 4 + }, + { + "function": "log", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.0a2b240000000p+1", + "max_ulp": 4 + }, + { + "function": "log", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "-0x1.bb9d3beb8c86bp+2", + "max_ulp": 4 + }, + { + "function": "log", + "dtype": "float64", + "inputs": [ + "0x1.8000000000000p-1" + ], + "expected": "-0x1.269621134db92p-2", + "max_ulp": 4 + }, + { + "function": "log", + "dtype": "float64", + "inputs": [ + "0x1.0040000000000p+0" + ], + "expected": "0x1.ffc00aa8ab110p-11", + "max_ulp": 4 + }, + { + "function": "log", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.0a2b23f3bab73p+1", + "max_ulp": 4 + }, + { + "function": "log10", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "-0x1.8151820000000p+1", + "max_ulp": 4 + }, + { + "function": "log10", + "dtype": "float32", + "inputs": [ + "0x1.8000000000000p-1" + ], + "expected": "-0x1.ffbfc20000000p-4", + "max_ulp": 4 + }, + { + "function": "log10", + "dtype": "float32", + "inputs": [ + "0x1.0040000000000p+0" + ], + "expected": "0x1.bc80240000000p-12", + "max_ulp": 4 + }, + { + "function": "log10", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.ce61d00000000p-1", + "max_ulp": 4 + }, + { + "function": "log10", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "-0x1.8151824c7587fp+1", + "max_ulp": 4 + }, + { + "function": "log10", + "dtype": "float64", + "inputs": [ + "0x1.8000000000000p-1" + ], + "expected": "-0x1.ffbfc2bbc7803p-4", + "max_ulp": 4 + }, + { + "function": "log10", + "dtype": "float64", + "inputs": [ + "0x1.0040000000000p+0" + ], + "expected": "0x1.bc80239e5b560p-12", + "max_ulp": 4 + }, + { + "function": "log10", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.ce61cf8ef36fep-1", + "max_ulp": 4 + }, + { + "function": "log1p", + "dtype": "float32", + "inputs": [ + "-0x1.c000000000000p-1" + ], + "expected": "-0x1.0a2b240000000p+1", + "max_ulp": 4 + }, + { + "function": "log1p", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.1178e80000000p-3", + "max_ulp": 4 + }, + { + "function": "log1p", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.ffc00a0000000p-11", + "max_ulp": 4 + }, + { + "function": "log1p", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.193ea80000000p+1", + "max_ulp": 4 + }, + { + "function": "log1p", + "dtype": "float64", + "inputs": [ + "-0x1.c000000000000p-1" + ], + "expected": "-0x1.0a2b23f3bab73p+1", + "max_ulp": 4 + }, + { + "function": "log1p", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.1178e8227e47cp-3", + "max_ulp": 4 + }, + { + "function": "log1p", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.ffc00aa8ab110p-11", + "max_ulp": 4 + }, + { + "function": "log1p", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.193ea7aad030bp+1", + "max_ulp": 4 + }, + { + "function": "log2", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "-0x1.4000000000000p+3", + "max_ulp": 4 + }, + { + "function": "log2", + "dtype": "float32", + "inputs": [ + "0x1.8000000000000p-1" + ], + "expected": "-0x1.a8ff980000000p-2", + "max_ulp": 4 + }, + { + "function": "log2", + "dtype": "float32", + "inputs": [ + "0x1.0040000000000p+0" + ], + "expected": "0x1.7126540000000p-10", + "max_ulp": 4 + }, + { + "function": "log2", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.8000000000000p+1", + "max_ulp": 4 + }, + { + "function": "log2", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "-0x1.4000000000000p+3", + "max_ulp": 4 + }, + { + "function": "log2", + "dtype": "float64", + "inputs": [ + "0x1.8000000000000p-1" + ], + "expected": "-0x1.a8ff971810a5ep-2", + "max_ulp": 4 + }, + { + "function": "log2", + "dtype": "float64", + "inputs": [ + "0x1.0040000000000p+0" + ], + "expected": "0x1.712653743f454p-10", + "max_ulp": 4 + }, + { + "function": "log2", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.8000000000000p+1", + "max_ulp": 4 + }, + { + "function": "sin", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.fa8d2a0000000p-1", + "max_ulp": 4 + }, + { + "function": "sin", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.feaaee0000000p-4", + "max_ulp": 4 + }, + { + "function": "sin", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.fffffa0000000p-11", + "max_ulp": 4 + }, + { + "function": "sin", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.d18f6e0000000p-1", + "max_ulp": 4 + }, + { + "function": "sin", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.fa8d2a028cf7bp-1", + "max_ulp": 4 + }, + { + "function": "sin", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.feaaeee86ee36p-4", + "max_ulp": 4 + }, + { + "function": "sin", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.fffffaaaaaaefp-11", + "max_ulp": 4 + }, + { + "function": "sin", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.d18f6ead1b446p-1", + "max_ulp": 4 + }, + { + "function": "sinh", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.749ea60000000p+10", + "max_ulp": 4 + }, + { + "function": "sinh", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.00aacc0000000p-3", + "max_ulp": 4 + }, + { + "function": "sinh", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.0000020000000p-10", + "max_ulp": 4 + }, + { + "function": "sinh", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.d03cf60000000p+1", + "max_ulp": 4 + }, + { + "function": "sinh", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.749ea514eca66p+10", + "max_ulp": 4 + }, + { + "function": "sinh", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.00aaccd00d2f1p-3", + "max_ulp": 4 + }, + { + "function": "sinh", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.000002aaaaacdp-10", + "max_ulp": 4 + }, + { + "function": "sinh", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.d03cf63b6e19fp+1", + "max_ulp": 4 + }, + { + "function": "sinpi", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+1" + ], + "expected": "0x0.0p+0", + "max_ulp": 8 + }, + { + "function": "sinpi", + "dtype": "float32", + "inputs": [ + "-0x1.8000000000000p-1" + ], + "expected": "-0x1.6a09e60000000p-1", + "max_ulp": 8 + }, + { + "function": "sinpi", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3" + ], + "expected": "0x1.87de2a0000000p-2", + "max_ulp": 8 + }, + { + "function": "sinpi", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-1" + ], + "expected": "0x1.0000000000000p+0", + "max_ulp": 8 + }, + { + "function": "sinpi", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+1" + ], + "expected": "0x0.0p+0", + "max_ulp": 8 + }, + { + "function": "sinpi", + "dtype": "float64", + "inputs": [ + "-0x1.8000000000000p-1" + ], + "expected": "-0x1.6a09e667f3bcdp-1", + "max_ulp": 8 + }, + { + "function": "sinpi", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3" + ], + "expected": "0x1.87de2a6aea963p-2", + "max_ulp": 8 + }, + { + "function": "sinpi", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-1" + ], + "expected": "0x1.0000000000000p+0", + "max_ulp": 8 + }, + { + "function": "sqrt", + "dtype": "float32", + "inputs": [ + "0x0.0p+0" + ], + "expected": "0x0.0p+0", + "max_ulp": 4 + }, + { + "function": "sqrt", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3" + ], + "expected": "0x1.6a09e60000000p-2", + "max_ulp": 4 + }, + { + "function": "sqrt", + "dtype": "float32", + "inputs": [ + "0x1.0040000000000p+0" + ], + "expected": "0x1.001ffe0000000p+0", + "max_ulp": 4 + }, + { + "function": "sqrt", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.6a09e60000000p+1", + "max_ulp": 4 + }, + { + "function": "sqrt", + "dtype": "float64", + "inputs": [ + "0x0.0p+0" + ], + "expected": "0x0.0p+0", + "max_ulp": 4 + }, + { + "function": "sqrt", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3" + ], + "expected": "0x1.6a09e667f3bcdp-2", + "max_ulp": 4 + }, + { + "function": "sqrt", + "dtype": "float64", + "inputs": [ + "0x1.0040000000000p+0" + ], + "expected": "0x1.001ffe003ff60p+0", + "max_ulp": 4 + }, + { + "function": "sqrt", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.6a09e667f3bcdp+1", + "max_ulp": 4 + }, + { + "function": "tan", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "0x1.b32e780000000p+2", + "max_ulp": 4 + }, + { + "function": "tan", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.01577a0000000p-3", + "max_ulp": 4 + }, + { + "function": "tan", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.0000060000000p-10", + "max_ulp": 4 + }, + { + "function": "tan", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "-0x1.17af620000000p+1", + "max_ulp": 4 + }, + { + "function": "tan", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "0x1.b32e78f49a1e4p+2", + "max_ulp": 4 + }, + { + "function": "tan", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.01577af1511a5p-3", + "max_ulp": 4 + }, + { + "function": "tan", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.0000055555777p-10", + "max_ulp": 4 + }, + { + "function": "tan", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "-0x1.17af62e0950f8p+1", + "max_ulp": 4 + }, + { + "function": "tanh", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.fffff80000000p-1", + "max_ulp": 4 + }, + { + "function": "tanh", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.fd59920000000p-4", + "max_ulp": 4 + }, + { + "function": "tanh", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.fffff60000000p-11", + "max_ulp": 4 + }, + { + "function": "tanh", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.ed95060000000p-1", + "max_ulp": 4 + }, + { + "function": "tanh", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.fffff872a91f8p-1", + "max_ulp": 4 + }, + { + "function": "tanh", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p-3" + ], + "expected": "-0x1.fd5992bc4b835p-4", + "max_ulp": 4 + }, + { + "function": "tanh", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-10" + ], + "expected": "0x1.fffff5555599ap-11", + "max_ulp": 4 + }, + { + "function": "tanh", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1" + ], + "expected": "0x1.ed9505e1bc3d4p-1", + "max_ulp": 4 + }, + { + "function": "tgamma", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3" + ], + "expected": "0x1.e22c1a0000000p+2", + "max_ulp": 8 + }, + { + "function": "tgamma", + "dtype": "float32", + "inputs": [ + "0x1.8000000000000p-1" + ], + "expected": "0x1.39b4e80000000p+0", + "max_ulp": 8 + }, + { + "function": "tgamma", + "dtype": "float32", + "inputs": [ + "0x1.8000000000000p+0" + ], + "expected": "0x1.c5bf8a0000000p-1", + "max_ulp": 8 + }, + { + "function": "tgamma", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.3b00000000000p+12", + "max_ulp": 8 + }, + { + "function": "tgamma", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3" + ], + "expected": "0x1.e22c196233d21p+2", + "max_ulp": 8 + }, + { + "function": "tgamma", + "dtype": "float64", + "inputs": [ + "0x1.8000000000000p-1" + ], + "expected": "0x1.39b4e8b50f62cp+0", + "max_ulp": 8 + }, + { + "function": "tgamma", + "dtype": "float64", + "inputs": [ + "0x1.8000000000000p+0" + ], + "expected": "0x1.c5bf891b4ef6bp-1", + "max_ulp": 8 + }, + { + "function": "tgamma", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+3" + ], + "expected": "0x1.3b00000000000p+12", + "max_ulp": 8 + }, + { + "function": "atan2", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+1", + "-0x1.8000000000000p+1" + ], + "expected": "-0x1.46dc0a0000000p+1", + "max_ulp": 4 + }, + { + "function": "atan2", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3", + "-0x1.0000000000000p+3" + ], + "expected": "0x1.901fc00000000p+1", + "max_ulp": 4 + }, + { + "function": "atan2", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1", + "0x1.8000000000000p+1" + ], + "expected": "0x1.2d0eae0000000p-1", + "max_ulp": 4 + }, + { + "function": "atan2", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+1", + "-0x1.8000000000000p+1" + ], + "expected": "-0x1.46dc09ec29433p+1", + "max_ulp": 4 + }, + { + "function": "atan2", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3", + "-0x1.0000000000000p+3" + ], + "expected": "0x1.901fbfee871a6p+1", + "max_ulp": 4 + }, + { + "function": "atan2", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1", + "0x1.8000000000000p+1" + ], + "expected": "0x1.2d0ead6066395p-1", + "max_ulp": 4 + }, + { + "function": "hypot", + "dtype": "float32", + "inputs": [ + "0x1.8000000000000p+1", + "0x1.0000000000000p+2" + ], + "expected": "0x1.4000000000000p+2", + "max_ulp": 4 + }, + { + "function": "hypot", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3", + "0x1.0000000000000p+3" + ], + "expected": "0x1.0008000000000p+3", + "max_ulp": 4 + }, + { + "function": "hypot", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1", + "0x1.8000000000000p+1" + ], + "expected": "0x1.cd82b40000000p+1", + "max_ulp": 4 + }, + { + "function": "hypot", + "dtype": "float64", + "inputs": [ + "0x1.8000000000000p+1", + "0x1.0000000000000p+2" + ], + "expected": "0x1.4000000000000p+2", + "max_ulp": 4 + }, + { + "function": "hypot", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3", + "0x1.0000000000000p+3" + ], + "expected": "0x1.0007ffe000fffp+3", + "max_ulp": 4 + }, + { + "function": "hypot", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1", + "0x1.8000000000000p+1" + ], + "expected": "0x1.cd82b446159f3p+1", + "max_ulp": 4 + }, + { + "function": "logaddexp", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3", + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.d3a37a0000000p+2", + "max_ulp": 8 + }, + { + "function": "logaddexp", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3", + "0x1.0000000000000p+3" + ], + "expected": "0x1.0000000000000p+3", + "max_ulp": 8 + }, + { + "function": "logaddexp", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3", + "0x1.0000000000000p-2" + ], + "expected": "0x1.c3e4060000000p-1", + "max_ulp": 8 + }, + { + "function": "logaddexp", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3", + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.d3a37a020b8c2p+2", + "max_ulp": 8 + }, + { + "function": "logaddexp", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3", + "0x1.0000000000000p+3" + ], + "expected": "0x1.0000003c6ab74p+3", + "max_ulp": 8 + }, + { + "function": "logaddexp", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3", + "0x1.0000000000000p-2" + ], + "expected": "0x1.c3e4055056374p-1", + "max_ulp": 8 + }, + { + "function": "pow", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3", + "0x1.8000000000000p+0" + ], + "expected": "0x1.6a09e60000000p-5", + "max_ulp": 4 + }, + { + "function": "pow", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+1", + "-0x1.8000000000000p-1" + ], + "expected": "0x1.306fe00000000p-1", + "max_ulp": 4 + }, + { + "function": "pow", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+3", + "0x1.0000000000000p-3" + ], + "expected": "0x1.4bfdae0000000p+0", + "max_ulp": 4 + }, + { + "function": "pow", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3", + "0x1.8000000000000p+0" + ], + "expected": "0x1.6a09e667f3bcdp-5", + "max_ulp": 4 + }, + { + "function": "pow", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+1", + "-0x1.8000000000000p-1" + ], + "expected": "0x1.306fe0a31b715p-1", + "max_ulp": 4 + }, + { + "function": "pow", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+3", + "0x1.0000000000000p-3" + ], + "expected": "0x1.4bfdad5362a27p+0", + "max_ulp": 4 + }, + { + "function": "fdim", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p+3", + "0x1.0000000000000p-3" + ], + "expected": "0x1.f800000000000p+2", + "max_ulp": 0 + }, + { + "function": "fdim", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3", + "0x1.0000000000000p+3" + ], + "expected": "0x0.0p+0", + "max_ulp": 0 + }, + { + "function": "fdim", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p+3", + "0x1.0000000000000p-3" + ], + "expected": "0x1.f800000000000p+2", + "max_ulp": 0 + }, + { + "function": "fdim", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3", + "0x1.0000000000000p+3" + ], + "expected": "0x0.0p+0", + "max_ulp": 0 + }, + { + "function": "fmin", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3", + "0x1.0000000000000p-3" + ], + "expected": "-0x1.0000000000000p+3", + "max_ulp": 0 + }, + { + "function": "fmin", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3", + "0x1.0000000000000p+3" + ], + "expected": "0x1.0000000000000p-3", + "max_ulp": 0 + }, + { + "function": "fmin", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3", + "0x1.0000000000000p-3" + ], + "expected": "-0x1.0000000000000p+3", + "max_ulp": 0 + }, + { + "function": "fmin", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3", + "0x1.0000000000000p+3" + ], + "expected": "0x1.0000000000000p-3", + "max_ulp": 0 + }, + { + "function": "fmax", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3", + "0x1.0000000000000p-3" + ], + "expected": "0x1.0000000000000p-3", + "max_ulp": 0 + }, + { + "function": "fmax", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3", + "0x1.0000000000000p+3" + ], + "expected": "0x1.0000000000000p+3", + "max_ulp": 0 + }, + { + "function": "fmax", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3", + "0x1.0000000000000p-3" + ], + "expected": "0x1.0000000000000p-3", + "max_ulp": 0 + }, + { + "function": "fmax", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3", + "0x1.0000000000000p+3" + ], + "expected": "0x1.0000000000000p+3", + "max_ulp": 0 + }, + { + "function": "copysign", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3", + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.0000000000000p-3", + "max_ulp": 0 + }, + { + "function": "copysign", + "dtype": "float32", + "inputs": [ + "-0x1.0000000000000p+3", + "0x1.0000000000000p-3" + ], + "expected": "0x1.0000000000000p+3", + "max_ulp": 0 + }, + { + "function": "copysign", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3", + "-0x1.0000000000000p+3" + ], + "expected": "-0x1.0000000000000p-3", + "max_ulp": 0 + }, + { + "function": "copysign", + "dtype": "float64", + "inputs": [ + "-0x1.0000000000000p+3", + "0x1.0000000000000p-3" + ], + "expected": "0x1.0000000000000p+3", + "max_ulp": 0 + }, + { + "function": "fmod", + "dtype": "float32", + "inputs": [ + "-0x1.0400000000000p+3", + "0x1.0000000000000p+1" + ], + "expected": "-0x1.0000000000000p-3", + "max_ulp": 0 + }, + { + "function": "fmod", + "dtype": "float32", + "inputs": [ + "0x1.0400000000000p+3", + "0x1.0000000000000p+1" + ], + "expected": "0x1.0000000000000p-3", + "max_ulp": 0 + }, + { + "function": "fmod", + "dtype": "float64", + "inputs": [ + "-0x1.0400000000000p+3", + "0x1.0000000000000p+1" + ], + "expected": "-0x1.0000000000000p-3", + "max_ulp": 0 + }, + { + "function": "fmod", + "dtype": "float64", + "inputs": [ + "0x1.0400000000000p+3", + "0x1.0000000000000p+1" + ], + "expected": "0x1.0000000000000p-3", + "max_ulp": 0 + }, + { + "function": "remainder", + "dtype": "float32", + "inputs": [ + "-0x1.c000000000000p+2", + "0x1.0000000000000p+1" + ], + "expected": "0x1.0000000000000p+0", + "max_ulp": 0 + }, + { + "function": "remainder", + "dtype": "float32", + "inputs": [ + "0x1.c000000000000p+2", + "0x1.0000000000000p+1" + ], + "expected": "0x1.0000000000000p+0", + "max_ulp": 0 + }, + { + "function": "remainder", + "dtype": "float32", + "inputs": [ + "-0x1.c000000000000p+2", + "-0x1.0000000000000p+1" + ], + "expected": "-0x1.0000000000000p+0", + "max_ulp": 0 + }, + { + "function": "remainder", + "dtype": "float32", + "inputs": [ + "0x1.c000000000000p+2", + "-0x1.0000000000000p+1" + ], + "expected": "-0x1.0000000000000p+0", + "max_ulp": 0 + }, + { + "function": "remainder", + "dtype": "float64", + "inputs": [ + "-0x1.c000000000000p+2", + "0x1.0000000000000p+1" + ], + "expected": "0x1.0000000000000p+0", + "max_ulp": 0 + }, + { + "function": "remainder", + "dtype": "float64", + "inputs": [ + "0x1.c000000000000p+2", + "0x1.0000000000000p+1" + ], + "expected": "0x1.0000000000000p+0", + "max_ulp": 0 + }, + { + "function": "remainder", + "dtype": "float64", + "inputs": [ + "-0x1.c000000000000p+2", + "-0x1.0000000000000p+1" + ], + "expected": "-0x1.0000000000000p+0", + "max_ulp": 0 + }, + { + "function": "remainder", + "dtype": "float64", + "inputs": [ + "0x1.c000000000000p+2", + "-0x1.0000000000000p+1" + ], + "expected": "-0x1.0000000000000p+0", + "max_ulp": 0 + }, + { + "function": "ldexp", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3", + "-0x1.0000000000000p+3" + ], + "expected": "0x1.0000000000000p-11", + "max_ulp": 0 + }, + { + "function": "ldexp", + "dtype": "float32", + "inputs": [ + "0x1.8000000000000p+0", + "0x1.0000000000000p+3" + ], + "expected": "0x1.8000000000000p+8", + "max_ulp": 0 + }, + { + "function": "ldexp", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3", + "-0x1.0000000000000p+3" + ], + "expected": "0x1.0000000000000p-11", + "max_ulp": 0 + }, + { + "function": "ldexp", + "dtype": "float64", + "inputs": [ + "0x1.8000000000000p+0", + "0x1.0000000000000p+3" + ], + "expected": "0x1.8000000000000p+8", + "max_ulp": 0 + }, + { + "function": "fma", + "dtype": "float32", + "inputs": [ + "0x1.0040000000000p+0", + "0x1.ff80000000000p-1", + "-0x1.0000000000000p+0" + ], + "expected": "-0x1.0000000000000p-20", + "max_ulp": 0 + }, + { + "function": "fma", + "dtype": "float32", + "inputs": [ + "0x1.0000000000000p-3", + "0x1.0000000000000p+3", + "-0x1.8000000000000p-1" + ], + "expected": "0x1.0000000000000p-2", + "max_ulp": 0 + }, + { + "function": "fma", + "dtype": "float64", + "inputs": [ + "0x1.0040000000000p+0", + "0x1.ff80000000000p-1", + "-0x1.0000000000000p+0" + ], + "expected": "-0x1.0000000000000p-20", + "max_ulp": 0 + }, + { + "function": "fma", + "dtype": "float64", + "inputs": [ + "0x1.0000000000000p-3", + "0x1.0000000000000p+3", + "-0x1.8000000000000p-1" + ], + "expected": "0x1.0000000000000p-2", + "max_ulp": 0 + } + ] +} diff --git a/scripts/qualify_without_numexpr.py b/scripts/qualify_without_numexpr.py new file mode 100644 index 000000000..4b81b9ea3 --- /dev/null +++ b/scripts/qualify_without_numexpr.py @@ -0,0 +1,88 @@ +"""Run pytest with NumExpr unavailable, without modifying a shared installation. + +CI uses --require-absent after uninstalling its optional reference package. Local +isolated builds can select a package root and a dependency-only search path that +omits both NumExpr and its distribution metadata. Optional external reference +tests see ModuleNotFoundError; direct Blosc2 import attempts fail qualification +even if an optional-import handler swallows that exception. +""" + +import argparse +import importlib.abc +import importlib.metadata +import json +import os +import sys +from pathlib import Path + + +class BlockNumExpr(importlib.abc.MetaPathFinder): + def __init__(self): + self.runtime_imports = [] + + def find_spec(self, fullname, path=None, target=None): + if fullname != "numexpr" and not fullname.startswith("numexpr."): + return + frame = sys._getframe(1) + try: + while frame: + owner = frame.f_globals.get("__name__", "") + if not owner.startswith(("importlib", "_frozen_importlib")): + if owner == "blosc2" or owner.startswith("blosc2."): + self.runtime_imports.append(owner) + break + frame = frame.f_back + finally: + del frame + raise ModuleNotFoundError("NumExpr is excluded from this qualification run", name="numexpr") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--require-absent", action="store_true") + parser.add_argument("--package-root", type=Path) + parser.add_argument("--dependencies", type=Path) + parser.add_argument("pytest_args", nargs=argparse.REMAINDER) + args = parser.parse_args() + if args.dependencies: + sys.path[:] = [p for p in sys.path if "site-packages" not in p and "dist-packages" not in p] + sys.path.insert(0, str(args.dependencies.resolve())) + if args.package_root: + sys.path.insert(0, str(args.package_root.resolve())) + selected = [str(path.resolve()) for path in (args.package_root, args.dependencies) if path is not None] + if selected: + os.environ["PYTHONPATH"] = os.pathsep.join(selected) + # pytest subprocesses inherit the selected package/dependency paths. The + # script's main guard is essential for multiprocessing's spawn start method. + if "numexpr" in sys.modules: + raise RuntimeError("NumExpr was imported before qualification started") + if args.require_absent: + try: + importlib.metadata.distribution("numexpr") + except importlib.metadata.PackageNotFoundError: + pass + else: + raise RuntimeError("NumExpr distribution is still installed on the qualification path") + if importlib.util.find_spec("numexpr") is not None: + raise RuntimeError("NumExpr module is still available on the qualification path") + blocker = BlockNumExpr() + sys.meta_path.insert(0, blocker) + import pytest + + import blosc2 + + assert blosc2.numexpr is None + requirements = importlib.metadata.requires("blosc2") or [] + assert not any(item.lower().startswith("numexpr") for item in requirements) + options = args.pytest_args + if options[:1] == ["--"]: + options = options[1:] + print(f"NumExpr-free package: {blosc2.__file__}", flush=True) + print(f"Native extension: {blosc2.blosc2_ext.__file__}", flush=True) + status = pytest.main(options) + print(json.dumps({"numexpr_runtime_imports": blocker.runtime_imports, "pytest_status": int(status)})) + return 1 if blocker.runtime_imports else int(status) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/verify_native_qualification.py b/scripts/verify_native_qualification.py new file mode 100644 index 000000000..de88c2db3 --- /dev/null +++ b/scripts/verify_native_qualification.py @@ -0,0 +1,64 @@ +"""Require completed full miniexpr qualification for an exact native revision.""" + +import argparse +import json +import os +import re +import urllib.request + + +def github_get(path): + headers = {"Accept": "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28"} + token = os.environ.get("GH_TOKEN") or os.environ.get("GITHUB_TOKEN") + if token: + headers["Authorization"] = f"Bearer {token}" + request = urllib.request.Request(f"https://api.github.com/repos/Blosc/miniexpr/{path}", headers=headers) + with urllib.request.urlopen(request, timeout=30) as response: + return json.load(response) + + +def verify(native_sha, get=github_get): + if not re.fullmatch(r"[0-9a-f]{40}", native_sha): + raise ValueError("Native qualification requires an exact, full lowercase commit SHA") + runs = get(f"actions/workflows/ci.yml/runs?head_sha={native_sha}&status=success&per_page=100") + for run in runs["workflow_runs"]: + if run["head_sha"] != native_sha or run["conclusion"] != "success": + continue + page = 1 + while True: + jobs = get(f"actions/runs/{run['id']}/jobs?filter=latest&per_page=100&page={page}") + if any( + job["name"] == "Publish full native qualification" + and job["status"] == "completed" + and job["conclusion"] == "success" + for job in jobs["jobs"] + ): + return { + "native_sha": native_sha, + "run_id": run["id"], + "url": run["html_url"], + "tier": "full", + } + if page * 100 >= jobs["total_count"]: + break + page += 1 + raise RuntimeError( + f"No successful full miniexpr qualification for {native_sha}. " + "Dispatch native CI at that revision with full_qualification=true first." + ) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("native_sha") + parser.add_argument("--output", default="native-qualification.json") + args = parser.parse_args() + evidence = verify(args.native_sha) + with open(args.output, "w") as output: + json.dump(evidence, output, indent=2) + output.write("\n") + print(f"Qualified native revision {args.native_sha}: {evidence['url']}") + + +if __name__ == "__main__": + main() diff --git a/scripts/verify_safe_lazyexpr.py b/scripts/verify_safe_lazyexpr.py new file mode 100644 index 000000000..b62b792b3 --- /dev/null +++ b/scripts/verify_safe_lazyexpr.py @@ -0,0 +1,101 @@ +"""Run the bounded safe-graph corpus and record actual platform/GIL/skip evidence. + +This verifies the selected tests, not the complete experiment's exit criteria. +It never disables the GIL or interprets free-threaded builds as no-GIL success. +""" + +import argparse +import importlib.util +import json +import platform +import sys +import sysconfig +from collections import Counter +from pathlib import Path + +import numpy as np +import pytest + +import blosc2 + + +class Outcomes: + def __init__(self): + self.cases = {} + + def pytest_collectreport(self, report): + if report.failed or report.skipped: + self.cases[report.nodeid] = { + "outcome": report.outcome, + "reason": str(report.longrepr), + "phase": "collection", + } + + def pytest_runtest_logreport(self, report): + if (report.when == "call" or report.failed or report.skipped) and self.cases.get( + report.nodeid, {} + ).get("outcome") != "failed": + result = {"outcome": report.outcome} + if report.skipped: + result["reason"] = str(report.longrepr) + self.cases[report.nodeid] = result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--report", type=Path) + args = parser.parse_args() + root = Path(__file__).resolve().parents[1] + selected = [ + "test_expression_graph.py", + "test_expression_graph_properties.py", + "test_expression_graph_lifetime.py", + "test_portable_lazy.py", + "ctable/test_ctable_computed_cols.py::test_safe_column_graph_observes_update_at_controlled_read_boundary", + "ctable/test_ctable_computed_cols.py::test_safe_portable_column_metadata_does_not_evaluate_rows", + ] + parquet = "ctable/test_remote_parquet.py" + if all(importlib.util.find_spec(name) is not None for name in ("pyarrow", "fsspec")): + selected += [ + f"{parquet}::{name}" + for name in ( + "test_safe_parquet_operand_checks_metadata_without_row_group_reads", + "test_safe_parquet_operand_rejects_invalid_lifetime_before_reads", + "test_safe_parquet_operand_rejects_same_metadata_storage_rebinding", + "test_safe_parquet_ndarray_operand_rejects_unreviewed_row_shape", + "test_safe_parquet_operand_rejects_hostile_dependencies_before_hooks", + "test_safe_parquet_graph_refresh_waits_for_read_and_invalidates_old_graph", + ) + ] + else: + # Collect the module itself so importorskip records absent adapters; + # node-qualified selectors for an uncollectable module can exit with 4. + selected.append(parquet) + outcomes = Outcomes() + code = pytest.main( + ["-q", "--override-ini", "addopts=", *[str(root / "tests" / name) for name in selected]], + plugins=[outcomes], + ) + result = { + "scope": "bounded experimental safe-graph corpus; not whole-project safety certification", + "exit_code": int(code), + "platform": platform.platform(), + "python": sys.version, + "numpy": np.__version__, + "blosc2": blosc2.__version__, + "c_blosc2": blosc2.blosclib_version, + "package": blosc2.__file__, + "free_threaded_build": bool(sysconfig.get_config_var("Py_GIL_DISABLED")), + "gil_enabled_after_tests": getattr(sys, "_is_gil_enabled", lambda: None)(), + "counts": dict(Counter(case["outcome"] for case in outcomes.cases.values())), + "exceptions": {name: case for name, case in outcomes.cases.items() if case["outcome"] != "passed"}, + } + text = json.dumps(result, indent=2) + if args.report: + args.report.write_text(text + "\n") + print(text) + return int(code) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/src/blosc2/__init__.py b/src/blosc2/__init__.py index 39008fd0b..c93b8b347 100644 --- a/src/blosc2/__init__.py +++ b/src/blosc2/__init__.py @@ -26,8 +26,7 @@ Flag for WebAssembly platform. """ -if not IS_WASM: - import numexpr +numexpr = None from .version import __array_api_version__, __version__ @@ -515,14 +514,6 @@ def _raise(exc): # Experiments say that, when using a large number of threads, it is better to not use them all if nthreads > 16: nthreads -= nthreads // 8 - # Only call set_num_threads if within NUMEXPR_MAX_THREADS limit to avoid warning - numexpr_max_env = os.environ.get("NUMEXPR_MAX_THREADS") - numexpr_max: int | None = None - if numexpr_max_env is not None: - with contextlib.suppress(ValueError): - numexpr_max = int(numexpr_max_env) - if numexpr_max is None or nthreads <= numexpr_max: - numexpr.set_num_threads(nthreads) # This import must be before ndarray and schunk from .storage import ( # noqa: I001 @@ -586,8 +577,18 @@ def _raise(exc): from .c2array import c2context, C2Array, C2NDSource, ChunkAlreadyWritten, URLPath -from .dsl_kernel import DSLSyntaxError, DSLKernel, dsl_kernel, validate_dsl, validate_dsl_jit +from .dsl_kernel import ( + DSLSyntaxError, + DSLKernel, + dsl_kernel, + validate_dsl, + validate_dsl_jit, + validate_portable_dsl, +) +from .portable_kernel import PortableArtifactError, PortableKernel +from .graph_plan import NativeGraph from .jit_config import get_jit_options, jit_options, set_jit_options +from .expression_graph import expression_evaluation from .lazyexpr import ( LazyExpr, lazyudf, @@ -601,6 +602,7 @@ def _raise(exc): result_type, can_cast, ) +from .prepared_evaluate import PreparedEvaluator, prepare_evaluate, re_evaluate from .proxy_source import ( ProxySource, ProxyNDSource, @@ -825,6 +827,8 @@ def _raise(exc): ndarray.NDArray = NDArray ndarray.NDField = NDField +from .menudet import MenudetKernel, menudet + __all__ = [ # noqa : RUF022 # Constants "EXTENDED_HEADER_LENGTH", @@ -908,8 +912,15 @@ def _raise(exc): "Index", "LazyArray", "DSLKernel", + "validate_portable_dsl", + "PortableKernel", + "NativeGraph", + "PortableArtifactError", "DSLSyntaxError", "LazyExpr", + "PreparedEvaluator", + "prepare_evaluate", + "re_evaluate", "LazyUDF", "ListArray", "NullPolicy", @@ -1052,6 +1063,8 @@ def _raise(exc): "jit", "lazyexpr", "dsl_kernel", + "menudet", + "MenudetKernel", "validate_dsl", "validate_dsl_jit", "lazyudf", diff --git a/src/blosc2/b2objects.py b/src/blosc2/b2objects.py index fc4c2cac7..65298a322 100644 --- a/src/blosc2/b2objects.py +++ b/src/blosc2/b2objects.py @@ -7,16 +7,16 @@ from __future__ import annotations -import inspect import pathlib -import textwrap -from dataclasses import asdict from typing import Any import numpy as np import blosc2 -from blosc2.dsl_kernel import DSLKernel, kernel_from_source +from blosc2.deserialization import DeserializeMode, get_deserialize, normalize_deserialize +from blosc2.dsl_kernel import kernel_from_source +from blosc2.exceptions import UnsafeDeserializationError +from blosc2.expression_graph import bounded_recipe _B2OBJECT_META_KEY = "b2o" _B2OBJECT_VERSION = 1 @@ -24,6 +24,23 @@ _B2OBJECT_USER_VLMETA_KEY = "_b2o_user_vlmeta" +def preflight_persistence(obj): + """Validate executable descriptors recursively before a destination is touched.""" + if isinstance(obj, blosc2.LazyArray): + encode_b2object_payload(obj) + from blosc2.msgpack_utils import msgpack_packb + + msgpack_packb(obj._get_user_vlmeta()) + elif isinstance(obj, blosc2.CTable): + obj._preflight_portable_persistence() + else: + schunk = getattr(obj, "schunk", obj if isinstance(obj, blosc2.SChunk) else None) + if schunk is not None: + marker = schunk.meta.get("b2o", {}) + if marker.get("kind") == "lazyudf" or schunk.meta.get("LazyArray") == 1: + raise TypeError("Persisting legacy DSL/Python UDF metadata is unsupported") + + def make_b2object_carrier( kind: str, shape, @@ -54,11 +71,42 @@ def read_b2object_user_vlmeta(obj) -> dict[str, Any]: return schunk.vlmeta[_B2OBJECT_USER_VLMETA_KEY] -def encode_operand_reference(obj): +def encode_operand_reference(obj, *, base_path=None): + from blosc2.portable_lazy import PortableLazyArray + + if isinstance(obj, PortableLazyArray | blosc2.LazyExpr | blosc2.LazyUDF): + return encode_b2object_payload(obj) + if type(obj) is blosc2.NDField: + parent = blosc2.Ref.from_object(obj.ndarr).to_dict() + if parent["kind"] == "urlpath" and base_path is not None: + path = pathlib.Path(parent["urlpath"]).absolute() + try: + parent["urlpath"] = path.relative_to(pathlib.Path(base_path).absolute()).as_posix() + except ValueError: + parent["urlpath"] = path.as_posix() + return { + "kind": "ndfield", + "version": 1, + "field": obj.field, + "parent": parent, + } return blosc2.Ref.from_object(obj).to_dict() -def decode_operand_reference(payload, *, base_path=None): +@bounded_recipe +def decode_operand_reference(payload, *, base_path=None, deserialize="safe"): + if payload.get("kind") == "ndfield": + if payload.get("version") != 1 or type(payload.get("field")) is not str: + raise ValueError("Invalid persisted NDField selector") + parent_payload = payload.get("parent") + if type(parent_payload) is not dict: + raise ValueError("Persisted NDField requires a parent reference") + if parent_payload.get("kind") == "ndfield": + raise ValueError("Persisted NDField parent cannot be another field") + parent = decode_operand_reference(parent_payload, base_path=base_path, deserialize=deserialize) + if type(parent) is not blosc2.NDArray: + raise ValueError("Persisted NDField parent must resolve to an NDArray") + return blosc2.NDField(parent, payload["field"]) if ( payload.get("kind") in {"urlpath", "dictstore_key"} and base_path is not None @@ -67,15 +115,25 @@ def decode_operand_reference(payload, *, base_path=None): payload = dict(payload) payload["urlpath"] = (base_path / payload["urlpath"]).as_posix() ref = blosc2.Ref.from_dict(payload) - return ref.open(deserialize="full") + return ref.open(deserialize=deserialize) def encode_b2object_payload(obj) -> dict[str, Any] | None: + from blosc2.portable_lazy import PortableLazyArray + + if isinstance(obj, PortableLazyArray): + return { + "kind": "portable", + "version": _B2OBJECT_VERSION, + "artifact": obj.kernel.to_json(), + "shape": list(obj._domain), + "partitions": list(obj.partitions), + "operands": {name: encode_operand_reference(value) for name, value in obj.inputs.items()}, + } if isinstance(obj, blosc2.C2Array): return blosc2.Ref.c2array_ref(obj.path, obj.urlbase).to_dict() if isinstance(obj, blosc2.LazyExpr): - expression = obj.expression_tosave if hasattr(obj, "expression_tosave") else obj.expression - operands = obj.operands_tosave if hasattr(obj, "operands_tosave") else obj.operands + expression, operands = obj._expression_recipe() return { "kind": "lazyexpr", "version": _B2OBJECT_VERSION, @@ -83,82 +141,85 @@ def encode_b2object_payload(obj) -> dict[str, Any] | None: "operands": {key: encode_operand_reference(value) for key, value in operands.items()}, } if isinstance(obj, blosc2.LazyUDF): - if not isinstance(obj.func, DSLKernel): - raise TypeError("Structured Blosc2 msgpack payload only supports LazyUDF backed by DSLKernel") - udf_func = obj.func.func - udf_name = getattr(udf_func, "__name__", obj.func.__name__) - try: - udf_source = textwrap.dedent(inspect.getsource(udf_func)).lstrip() - except Exception: - udf_source = obj.func.dsl_source - if udf_source is None: - raise ValueError("Structured LazyUDF msgpack payload requires recoverable DSL kernel source") - kwargs = {} - for key, value in obj.kwargs.items(): - if key in {"dtype", "shape"}: - continue - if isinstance(value, blosc2.CParams | blosc2.DParams): - kwargs[key] = asdict(value) - else: - kwargs[key] = value - return { - "kind": "lazyudf", - "version": _B2OBJECT_VERSION, - "function_kind": "dsl", - "dsl_version": _B2OBJECT_DSL_VERSION, - "name": udf_name, - "udf_source": udf_source, - "dtype": np.dtype(obj.dtype).str, - "shape": list(obj.shape), - "operands": {f"o{i}": encode_operand_reference(value) for i, value in enumerate(obj.inputs)}, - "kwargs": kwargs, - } + from blosc2.portable_lazy import portable_from_lazyudf + + return encode_b2object_payload(portable_from_lazyudf(obj)) return None -def decode_b2object_payload(payload: dict[str, Any], *, carrier_path=None, carrier=None): +@bounded_recipe +def decode_b2object_payload(payload: dict[str, Any], *, carrier_path=None, carrier=None, deserialize="safe"): + deserialize = normalize_deserialize(deserialize) kind = payload.get("kind") version = payload.get("version") if version != _B2OBJECT_VERSION: raise ValueError(f"Unsupported persisted Blosc2 object version: {version!r}") if kind == "c2array": ref = blosc2.Ref.from_dict(payload) - return ref.open(deserialize="full") + return ref.open(deserialize=deserialize) + if kind == "portable": + kernel = blosc2.PortableKernel.from_json(payload["artifact"]) + operands, missing = decode_operand_mapping( + payload["operands"], base_path=carrier_path, deserialize=deserialize + ) + if missing: + raise FileNotFoundError(f"Missing portable operands: {missing}") + return kernel.lazy(operands, shape=payload["shape"], partitions=payload["partitions"]) if kind == "remote_array": if carrier is None: raise ValueError("A persisted RemoteArray requires its B2ND carrier") return blosc2.RemoteArray._from_payload(payload, carrier) if kind == "lazyexpr": - return decode_structured_lazyexpr(payload, carrier_path=carrier_path) + return decode_structured_lazyexpr(payload, carrier_path=carrier_path, deserialize=deserialize) if kind == "lazyudf": - return decode_structured_lazyudf(payload, carrier_path=carrier_path) + if deserialize is not DeserializeMode.FULL: + raise UnsafeDeserializationError("legacy DSL LazyUDF") + return decode_structured_lazyudf(payload, carrier_path=carrier_path, deserialize=deserialize) raise ValueError(f"Unsupported persisted Blosc2 object kind: {kind!r}") -def decode_structured_lazyexpr(payload, *, carrier_path=None): +def decode_structured_lazyexpr(payload, *, carrier_path=None, deserialize="safe"): expression = payload.get("expression") if not isinstance(expression, str): raise TypeError("Structured LazyExpr payload requires a string 'expression'") operands_payload = payload.get("operands") if not isinstance(operands_payload, dict): raise TypeError("Structured LazyExpr payload requires a mapping 'operands'") - operands, missing_ops = decode_operand_mapping(operands_payload, base_path=carrier_path) + from blosc2.expression_graph import parse_expression, select_evaluation + from blosc2.lazyexpr import validate_expr + + if normalize_deserialize(deserialize) is DeserializeMode.SAFE: + parse_expression(expression) + else: + validate_expr(expression) + operands, missing_ops = decode_operand_mapping( + operands_payload, base_path=carrier_path, deserialize=deserialize + ) if missing_ops: exc = blosc2.exceptions.MissingOperands(expression, missing_ops) exc.expr = expression exc.missing_ops = missing_ops raise exc - return blosc2.lazyexpr(expression, operands=operands) + mode = select_evaluation(expression, operands, str(deserialize)) + return blosc2.lazyexpr(expression, operands=operands, evaluation=mode) -def decode_operand_mapping(operands_payload, *, base_path=None): +def decode_operand_mapping(operands_payload, *, base_path=None, deserialize="safe"): + if normalize_deserialize(deserialize) is DeserializeMode.SAFE: + _preflight_operand_recipes(operands_payload) operands = {} missing_ops = {} for key, value in operands_payload.items(): try: - operands[key] = decode_operand_reference(value, base_path=base_path) + if value.get("kind") in {"portable", "lazyexpr", "lazyudf"}: + operands[key] = decode_b2object_payload( + value, carrier_path=base_path, deserialize=deserialize + ) + else: + operands[key] = decode_operand_reference(value, base_path=base_path, deserialize=deserialize) except FileNotFoundError: - ref = blosc2.Ref.from_dict(value) + reference = value["parent"] if value.get("kind") == "ndfield" else value + ref = blosc2.Ref.from_dict(reference) if ref.kind in {"urlpath", "dictstore_key"}: missing_ops[key] = pathlib.Path(ref.urlpath) else: @@ -166,7 +227,35 @@ def decode_operand_mapping(operands_payload, *, base_path=None): return operands, missing_ops -def decode_structured_lazyudf(payload, *, carrier_path=None): +def _preflight_operand_recipes(mapping, active=()): + """Check the entire inline recipe closure before resolving any sibling refs.""" + from blosc2.expression_graph import parse_expression + + if type(mapping) is not dict: + raise TypeError("Structured operands require a concrete mapping") + if id(mapping) in active or len(active) >= 64: + raise UnsafeDeserializationError("cyclic or excessively deep saved expression recipes") + active = (*active, id(mapping)) + for key, payload in mapping.items(): + if type(key) is not str or type(payload) is not dict: + raise TypeError("Structured operands require string keys and concrete recipe mappings") + kind = payload.get("kind") + if type(kind) is not str: + raise TypeError("Structured operand recipe requires a string kind") + if kind == "lazyudf": + raise UnsafeDeserializationError("legacy DSL LazyUDF") + if kind == "lazyexpr": + expression = payload.get("expression") + if type(expression) is not str: + raise TypeError("Structured LazyExpr payload requires a string 'expression'") + parse_expression(expression) + if kind in {"lazyexpr", "portable"}: + _preflight_operand_recipes(payload.get("operands"), active) + + +def decode_structured_lazyudf(payload, *, carrier_path=None, deserialize="safe"): + if normalize_deserialize(deserialize) is not DeserializeMode.FULL: + raise UnsafeDeserializationError("legacy DSL LazyUDF") function_kind = payload.get("function_kind") if function_kind != "dsl": raise ValueError(f"Unsupported structured LazyUDF function kind: {function_kind!r}") @@ -194,15 +283,19 @@ def decode_structured_lazyudf(payload, *, carrier_path=None): func = kernel_from_source(udf_source, name) ordered_operands_payload = {f"o{n}": operands_payload[f"o{n}"] for n in range(len(operands_payload))} - operands, missing_ops = decode_operand_mapping(ordered_operands_payload, base_path=carrier_path) + operands, missing_ops = decode_operand_mapping( + ordered_operands_payload, base_path=carrier_path, deserialize=deserialize + ) if missing_ops: exc = blosc2.exceptions.MissingOperands(name, missing_ops) exc.expr = name exc.missing_ops = missing_ops raise exc - return blosc2.lazyudf( + result = blosc2.lazyudf( func, tuple(operands.values()), dtype=np.dtype(dtype), shape=tuple(shape_payload), **kwargs ) + result._legacy_source_recipe = True + return result def read_b2object_marker(obj) -> dict[str, Any] | None: @@ -231,8 +324,13 @@ def open_b2object(obj): schunk = getattr(obj, "schunk", obj) if getattr(schunk, "urlpath", None) is not None: carrier_path = pathlib.Path(schunk.urlpath).parent - opened = decode_b2object_payload(payload, carrier_path=carrier_path, carrier=obj) - if isinstance(opened, blosc2.LazyExpr | blosc2.LazyUDF): + opened = decode_b2object_payload( + payload, carrier_path=carrier_path, carrier=obj, deserialize=get_deserialize(obj) + ) + from blosc2.deserialization import set_deserialize + + set_deserialize(opened, get_deserialize(obj)) + if isinstance(opened, blosc2.LazyArray): opened.array = obj opened.schunk = schunk opened._set_user_vlmeta(read_b2object_user_vlmeta(obj), sync=False) diff --git a/src/blosc2/blosc2_ext.pyx b/src/blosc2/blosc2_ext.pyx index 64affa623..ffdf26522 100644 --- a/src/blosc2/blosc2_ext.pyx +++ b/src/blosc2/blosc2_ext.pyx @@ -728,7 +728,6 @@ cdef extern from "miniexpr.h": ME_COMPILE_ERR_OOM ME_COMPILE_ERR_PARSE ME_COMPILE_ERR_INVALID_ARG - ME_COMPILE_ERR_COMPLEX_UNSUPPORTED ME_COMPILE_ERR_REDUCTION_INVALID ME_COMPILE_ERR_VAR_MIXED ME_COMPILE_ERR_VAR_UNSPECIFIED @@ -961,6 +960,1597 @@ cdef inline object _numpy_dtype_from_me_dtype(me_dtype dt): return None +cdef extern from *: + """ + #include "miniexpr.h" + #include + #include + static int b2_validate_portable_dsl(const char *source, const char *version, + const me_variable *inputs, int ninputs, me_dtype output_dtype, + size_t output_itemsize, int ndim, int cardinality, + int *line, int *column, char *message, size_t capacity) { + #ifdef ME_PORTABLE_DSL_VALIDATION_DESCRIPTOR_VERSION + if (strcmp(ME_PORTABLE_DSL_VERSION, "1.0")) { + *line = *column = 0; + snprintf(message, capacity, "installed miniexpr lacks draft 1.0 source validation"); + return -100; + } + me_portable_error error = {0}; + int rc; + me_portable_validation_descriptor descriptor = { + .struct_size = sizeof(descriptor), + .version = ME_PORTABLE_DSL_VALIDATION_DESCRIPTOR_VERSION, + .output_itemsize = output_itemsize, .ndim = ndim, + .cardinality = (me_portable_cardinality)cardinality}; + rc = me_validate_portable_dsl_ex(source, version, inputs, ninputs, + output_dtype, &descriptor, &error); + *line = error.line; + *column = error.column; + snprintf(message, capacity, "%s", error.message); + return rc; + #else + *line = *column = 0; + snprintf(message, capacity, "miniexpr was built without draft 1.0 source validation support"); + return -100; + #endif + } + """ + int b2_validate_portable_dsl(const char *source, const char *version, + const me_variable *inputs, int ninputs, me_dtype output_dtype, + size_t output_itemsize, int ndim, int cardinality, + int *line, int *column, char *message, size_t capacity) + + +def validate_portable_dsl_source(source, input_dtypes, output_dtype, version, int ndim=0, int cardinality=0): + """Native-only versioned source validation; no arrays, JIT or Python execution.""" + cdef Py_ssize_t n = len(input_dtypes) + if n > 128: + raise ValueError("Too many portable DSL inputs (maximum 128)") + cdef me_variable *variables = NULL + cdef list names = [name.encode("utf-8") for name in input_dtypes] + cdef bytes source_bytes = source.encode("utf-8") + cdef bytes version_bytes = version.encode("utf-8") + cdef bytes name_bytes + cdef np.dtype dtype + cdef me_dtype result_dtype + cdef size_t output_itemsize = 0 + cdef int rc, line = 0, column = 0 + cdef char message[256] + cdef Py_ssize_t i + if n: + variables = calloc(n, sizeof(me_variable)) + if variables == NULL: + raise MemoryError() + try: + for i, value in enumerate(input_dtypes.values()): + name_bytes = names[i] + variables[i].name = name_bytes + dtype = np.dtype(value) + try: + variables[i].dtype = _me_dtype_from_numpy_dtype(dtype) + except TypeError: + variables[i].dtype = ME_AUTO + if version == "1.0" and variables[i].dtype in (ME_STRING, ME_BYTES): + variables[i].itemsize = dtype.itemsize + dtype = np.dtype(output_dtype) + try: + result_dtype = _me_dtype_from_numpy_dtype(dtype) + except TypeError: + result_dtype = ME_AUTO + if version == "1.0" and result_dtype in (ME_STRING, ME_BYTES): + output_itemsize = dtype.itemsize + rc = b2_validate_portable_dsl(source_bytes, version_bytes, variables, n, + result_dtype, output_itemsize, ndim, cardinality, + &line, &column, message, sizeof(message)) + statuses = { + 0: "success", -1: "unsupported_version", -2: "invalid_signature", + -3: "invalid_source", -4: "unsupported_feature", -5: "out_of_memory", + -100: "runtime_unsupported", + } + return {"valid": rc == 0, "status": statuses.get(rc, "native_error"), + "line": line, "column": column, + "error": None if rc == 0 else (message).decode("utf-8", "replace")} + finally: + free(variables) + + +cdef extern from "dsl_artifact_bridge.h": + ctypedef struct b2_artifact_input: + const char *name + me_dtype dtype + const void *data + size_t nitems + ctypedef struct b2_artifact_error: + int native_status + int line + int column + char message[256] + int b2_artifact_available() + int b2_artifact_load(const char *, size_t, int, void **, b2_artifact_error *) nogil + int b2_artifact_load_options(const char *, size_t, int, const me_jit_options *, void **, b2_artifact_error *) nogil + int b2_artifact_load_inferred(const char *, size_t, int, const me_jit_options *, void **, b2_artifact_error *) nogil + int b2_artifact_load_inferred_available() + int b2_artifact_options_available() + int b2_artifact_eval(const void *, const b2_artifact_input *, int, void *, size_t, + b2_artifact_error *) nogil + void b2_artifact_free(void *) noexcept nogil + const char *b2_artifact_source(const void *) + const char *b2_artifact_entry(const void *) + int b2_artifact_ninputs(const void *) + const char *b2_artifact_name(const void *, int) + me_dtype b2_artifact_dtype(const void *, int) + me_dtype b2_artifact_output(const void *) + me_dtype b2_artifact_inferred(const void *) + ctypedef struct b2_artifact_fp_status: + unsigned flags + unsigned supported + int b2_artifact_eval_status(const void *, const b2_artifact_buffer *, int, void *, + const b2_artifact_descriptor *, unsigned, b2_artifact_fp_status *, b2_artifact_error *) nogil + int b2_artifact_jit(const void *) + int b2_artifact_auto_jit_mode() + const char *b2_artifact_execution_kind(const void *) + ctypedef struct b2_artifact_buffer: + const char *name + me_dtype dtype + size_t itemsize + const void *data + size_t capacity + ctypedef struct b2_artifact_descriptor: + size_t struct_size + unsigned int version + size_t nitems + size_t output_capacity + const uint8_t *valid_mask + size_t valid_mask_capacity + int ndim + const int64_t *logical_shape + const int64_t *block_origin + const int64_t *block_extent + int b2_artifact_descriptor_available() + int b2_artifact_cardinality(const void *) + size_t b2_artifact_width(const void *, int) + int b2_artifact_rank(const void *) + const char *b2_artifact_version(const void *) + const char *b2_artifact_math(const void *) + const char *b2_artifact_math_ulp(const void *) + const char *b2_artifact_fp(const void *) + int b2_artifact_eval_ex(const void *, const b2_artifact_buffer *, int, void *, + const b2_artifact_descriptor *, b2_artifact_error *) nogil + +cdef extern from "dsl_array_bridge.h": + ctypedef struct b2_array_view: + const char *name + me_dtype dtype + const void *base + size_t capacity + size_t offset + int rank + int64_t shape[16] + int64_t strides[16] + unsigned byte_order + ctypedef struct b2_array_options: + unsigned version + int reduction + int naxes + int axes[16] + bint keepdims + me_dtype accumulator + const void *initial + size_t tile_items + const b2_array_view *where + ctypedef struct b2_array_report: + size_t temporary_bytes + size_t gathered_bytes + size_t zero_copy_tiles + size_t evaluated_tiles + unsigned fp_flags + unsigned fp_supported + int b2_array_shape(const void *, int, const int64_t *, const b2_array_options *, int *, int64_t *, me_dtype *, b2_artifact_error *) nogil + int b2_array_eval(const void *, const b2_array_view *, int, int, const int64_t *, const b2_array_options *, void *, size_t, b2_array_report *, b2_artifact_error *) nogil + ctypedef int (*b2_array_reader)(void *, const size_t *, size_t, void *, size_t) noexcept nogil + ctypedef struct b2_array_source: + b2_array_view view + b2_array_reader read + void *owner + int b2_array_sources_available() + int b2_array_eval_sources(const void *, const b2_array_source *, int, int, const int64_t *, const b2_array_options *, void *, size_t, b2_array_report *, b2_artifact_error *) nogil + + +cdef struct portable_prefilter_worker: + void *edge_output + b2_artifact_buffer *bindings + blosc2_context **decoders + int status + int64_t error_block + b2_artifact_error error + unsigned fp_flags + unsigned fp_supported + size_t evaluated_blocks + size_t output_zero_fill_bytes + + +cdef struct portable_prefilter_state: + const void *artifact + int ndim + int grid_ndim + bint diagonal_enabled + int64_t diagonal + int64_t shape[16] + int64_t chunkshape[16] + int64_t blockshape[16] + int64_t chunkgrid[16] + int64_t blockgrid[16] + uint8_t *numpy_output + const uint8_t *numpy_inputs[128] + b2nd_array_t *inputs[128] + b2_artifact_buffer signature[128] + uint8_t *chunks[128] + int chunk_bytes[128] + c_bool chunk_owned[128] + int ninputs + int nworkers + portable_prefilter_worker *workers + int64_t size + int64_t chunk_items + int64_t block_items + int status + int64_t error_block + b2_artifact_error error + unsigned fp_flags + unsigned fp_supported + size_t evaluated_blocks + size_t output_zero_fill_bytes + + +cdef void portable_prefilter_merge(portable_prefilter_state *state) noexcept: + """Merge worker-local status only after synchronous compression has joined.""" + cdef portable_prefilter_worker *worker + cdef int tid + state.fp_flags = 0 + state.fp_supported = 1 + state.evaluated_blocks = 0 + state.output_zero_fill_bytes = 0 + for tid in range(state.nworkers): + worker = &state.workers[tid] + if worker.status and (not state.status or worker.error_block < state.error_block): + state.status = worker.status + state.error = worker.error + state.error_block = worker.error_block + state.fp_flags |= worker.fp_flags + state.fp_supported &= worker.fp_supported + state.evaluated_blocks += worker.evaluated_blocks + state.output_zero_fill_bytes += worker.output_zero_fill_bytes + + +cdef extern from "fenv.h": + ctypedef struct fenv_t: + pass + int feholdexcept(fenv_t *) noexcept nogil + int fesetenv(const fenv_t *) noexcept nogil + + +cdef int portable_menudet_prefilter(blosc2_prefilter_params *params) noexcept nogil: + cdef portable_prefilter_state *state = params.user_data + cdef portable_prefilter_worker *worker = &state.workers[params.tid] + cdef b2_artifact_descriptor descriptor + cdef b2_artifact_error error + cdef b2_artifact_fp_status fp + cdef blosc2_dparams dparams + cdef int i, rc = 0, read_status + cdef int32_t block_bytes + cdef int64_t origin = params.nchunk * state.chunk_items + params.nblock * state.block_items + cdef int64_t count = min(state.block_items, state.size - origin) + cdef int64_t block_id = origin // state.block_items + cdef int64_t logical_shape = state.size + cdef int64_t block_origin = origin + cdef int64_t block_extent = count + cdef size_t written_bytes = max(count, 0) * params.output_typesize + cdef void *destination = params.output + cdef fenv_t environment + cdef int d + cdef int64_t chunk_index, block_index, lane, offset, physical, stride, relative + cdef int64_t origins[16] + cdef int64_t extents[16] + cdef bint edge = False + if state.grid_ndim > 1: + chunk_index = params.nchunk + block_index = params.nblock + count = 1 + block_id = params.nchunk * (state.chunk_items // state.block_items) + params.nblock + for d in range(state.grid_ndim - 1, -1, -1): + origins[d] = (chunk_index % state.chunkgrid[d]) * state.chunkshape[d] + chunk_index //= state.chunkgrid[d] + relative = (block_index % state.blockgrid[d]) * state.blockshape[d] + origins[d] += relative + block_index //= state.blockgrid[d] + extents[d] = max(0, min(state.blockshape[d], state.shape[d] - origins[d], + state.chunkshape[d] - relative)) + count *= extents[d] + edge |= extents[d] != state.blockshape[d] + if not params.output_is_disposable: + worker.output_zero_fill_bytes += params.output_size + elif edge: + memset(params.output, 0, params.output_size) + worker.output_zero_fill_bytes += params.output_size + if not count: + return 0 + # An eye constructor owns this scheduling hint: blocks outside its + # diagonal contain only zeros and need no artifact evaluation. + if state.diagonal_enabled and (state.diagonal < origins[1] - origins[0] - extents[0] + 1 + or state.diagonal > origins[1] + extents[1] - 1 - origins[0]): + if params.output_is_disposable: + memset(params.output, 0, params.output_size) + return 0 + destination = params.output + if edge: + if worker.edge_output == NULL: + worker.edge_output = malloc(state.block_items * params.output_typesize) + if worker.edge_output == NULL: + worker.status = -6 + worker.error_block = block_id + strcpy(worker.error.message, "Cannot allocate portable prefilter edge output") + return -1 + destination = worker.edge_output + memset(&descriptor, 0, sizeof(descriptor)) + memset(&error, 0, sizeof(error)) + memset(&fp, 0, sizeof(fp)) + descriptor.struct_size = sizeof(descriptor) + descriptor.version = 1 + descriptor.nitems = count + descriptor.output_capacity = count * params.output_typesize + descriptor.ndim = state.ndim + if state.ndim: + descriptor.logical_shape = state.shape + descriptor.block_origin = origins + descriptor.block_extent = extents + if feholdexcept(&environment): + worker.status = -5 + strcpy(worker.error.message, "Cannot isolate portable prefilter floating environment") + return -1 + rc = b2_artifact_eval_status(state.artifact, NULL, 0, destination, &descriptor, 0, &fp, &error) + if fesetenv(&environment): + rc = -5 + strcpy(error.message, "Cannot restore portable prefilter floating environment") + if rc: + worker.status = rc + worker.error = error + worker.error_block = block_id + memset(params.output, 0, params.output_size) + return -1 + if edge: + for lane in range(count): + offset = lane + physical = 0 + stride = 1 + for d in range(state.grid_ndim - 1, -1, -1): + relative = offset % extents[d] + offset //= extents[d] + physical += relative * stride + stride *= state.blockshape[d] + memcpy(params.output + physical * params.output_typesize, + destination + lane * params.output_typesize, params.output_typesize) + worker.fp_flags |= fp.flags + worker.fp_supported &= fp.supported + worker.evaluated_blocks += 1 + return 0 + memset(&error, 0, sizeof(error)) + memset(&fp, 0, sizeof(fp)) + if state.numpy_output != NULL and count <= 0: + return 1 + # Elementwise evaluation overwrites all live lanes. Only padded lanes in + # the final physical chunk must be cleared before storing/compressing them. + if state.numpy_output != NULL: + destination = state.numpy_output + origin * params.output_typesize + elif not params.output_is_disposable: + # C-Blosc2 itself clears non-disposable prefilter outputs. + worker.output_zero_fill_bytes += params.output_size + elif written_bytes < params.output_size: + memset(params.output + written_bytes, 0, params.output_size - written_bytes) + worker.output_zero_fill_bytes += params.output_size - written_bytes + if count <= 0: + return 0 + if feholdexcept(&environment): + memset(params.output, 0, params.output_size) + worker.status = -5 + worker.error_block = block_id + strcpy(worker.error.message, "Cannot isolate portable prefilter floating environment") + return -1 + for i in range(state.ninputs): + if state.numpy_inputs[i] != NULL: + worker.bindings[i].data = state.numpy_inputs[i] + origin * worker.bindings[i].itemsize + worker.bindings[i].capacity = count * worker.bindings[i].itemsize + continue + block_bytes = state.block_items * worker.bindings[i].itemsize + # Allocate lazily: small chunks may use only a subset of the configured + # compression workers. Each active worker reuses these across chunks. + if worker.bindings[i].data == NULL: + worker.bindings[i].data = malloc(block_bytes) + if worker.bindings[i].data == NULL: + rc = -6 + strcpy(error.message, "Cannot allocate portable prefilter input block") + break + if worker.decoders[i] == NULL: + dparams = state.inputs[i].sc.storage.dparams[0] + dparams.nthreads = 1 + dparams.schunk = state.inputs[i].sc + dparams.typesize = state.inputs[i].sc.typesize + worker.decoders[i] = blosc2_create_dctx(dparams) + if worker.decoders[i] == NULL: + rc = -6 + strcpy(error.message, "Cannot allocate portable prefilter decoder") + break + worker.bindings[i].capacity = count * worker.bindings[i].itemsize + read_status = blosc2_getitem_bytes_ctx(worker.decoders[i], state.chunks[i], state.chunk_bytes[i], + params.nblock * block_bytes, block_bytes, worker.bindings[i].data, block_bytes) + if read_status != block_bytes: + rc = -5 + error.native_status = read_status + strcpy(error.message, "Portable prefilter input decompression failed") + break + if not rc: + memset(&descriptor, 0, sizeof(descriptor)) + descriptor.struct_size = sizeof(descriptor) + descriptor.version = 1 + descriptor.nitems = count + descriptor.output_capacity = count * params.output_typesize + if state.ndim: + descriptor.ndim = 1 + descriptor.logical_shape = &logical_shape + descriptor.block_origin = &block_origin + descriptor.block_extent = &block_extent + # Decoder/postfilter work must not contribute to numerical FP flags. + rc = b2_artifact_eval_status(state.artifact, worker.bindings, state.ninputs, + destination, &descriptor, 0, &fp, &error) + if fesetenv(&environment): + rc = -5 + strcpy(error.message, "Cannot restore portable prefilter floating environment") + if rc and (worker.status == 0 or block_id < worker.error_block): + worker.status = rc + worker.error = error + worker.error_block = block_id + if rc: + # Disposable prefilters do not propagate failures through C-Blosc2; + # return deterministic bytes until the caller raises worker status. + memset(params.output, 0, params.output_size) + if not rc: + worker.fp_flags |= fp.flags + worker.fp_supported &= fp.supported + worker.evaluated_blocks += 1 + # External destinations need no filter/compressor work. With disposable + # output this return value skips filters; Blosc2 emits a tiny zero-run chunk. + return -1 if rc else (1 if state.numpy_output != NULL else 0) + + +def portable_prefilter_available(): + return bool(b2_artifact_descriptor_available()) + + +def portable_resident_available(): + return bool(b2_artifact_descriptor_available()) + + +def native_array_sources_available(): + return bool(b2_array_sources_available()) + + +cdef int storage_reader_callback(void *opaque, const size_t *indices, size_t count, + void *destination, size_t capacity) noexcept with gil: + cdef object state = opaque + cdef np.npy_intp dimensions[1] + cdef np.ndarray requested, values + try: + dimensions[0] = count + requested = np.PyArray_SimpleNewFromData(1, dimensions, np.NPY_UINTP, indices) + # Exceptions/tracebacks may outlive the native invocation scratch. + requested = requested.copy() + requested.flags.writeable = False + values = np.ascontiguousarray(state.reader.read(requested), dtype=state.dtype) + if values.size != count or values.nbytes != capacity: + raise ValueError("Storage reader returned an invalid value count") + memcpy(destination, np.PyArray_DATA(values), capacity) + state.max_items = max(state.max_items, count) + state.read_bytes += capacity + return 0 + except BaseException as error: + state.error = error + return 1 + + +cdef struct graph_span_reader_state: + b2nd_array_t *array + blosc2_context *dctx + int64_t origin + int64_t extent + int64_t chunk_id + uint8_t *chunk + int chunk_bytes + c_bool needs_free + size_t maximum_items + size_t read_bytes + + +cdef int graph_span_reader_callback(void *opaque, const size_t *indices, size_t count, + void *destination, size_t capacity) noexcept nogil: + """Invocation-owned decoder/chunk cache; no Python or full-array buffers.""" + cdef graph_span_reader_state *state = opaque + cdef size_t i, done = 0, take + cdef int64_t first, chunk_id, offset + cdef int rc + cdef int32_t decoded, encoded, block_bytes, wanted + cdef int typesize = state.array.sc.typesize + if not count: + return 0 + if typesize <= 0 or count > 2147483647 or count > capacity // typesize or capacity != count * typesize: + return 1 + if indices[0] >= state.extent or count > state.extent - indices[0]: + return 1 + for i in range(1, count): + if indices[i] != indices[0] + i: + return 1 + first = state.origin + indices[0] + while done < count: + chunk_id = (first + done) // state.array.chunknitems + offset = (first + done) % state.array.chunknitems + take = min(count - done, (state.array.chunknitems - offset)) + if state.chunk == NULL or state.chunk_id != chunk_id: + if state.needs_free: + free(state.chunk) + state.chunk = NULL + state.needs_free = False + state.chunk_bytes = blosc2_schunk_get_lazychunk(state.array.sc, chunk_id, + &state.chunk, &state.needs_free) + state.chunk_id = chunk_id + if state.chunk_bytes < 0 or state.chunk == NULL: + return 1 + rc = blosc2_cbuffer_sizes(state.chunk, &decoded, &encoded, &block_bytes) + if rc < 0 or decoded < 0 or block_bytes <= 0 or block_bytes % typesize or offset + take > (decoded // typesize): + return 1 + # Keep each request inside one physical block. Besides avoiding the + # decoder's multi-block copy, this prevents an unaligned block-sized + # request from taking C-Blosc2's single-block destination shortcut on + # its second block and overwriting already-decoded leading values. + take = min(take, (block_bytes // typesize - offset % (block_bytes // typesize))) + wanted = take * typesize + rc = blosc2_getitem_bytes_ctx(state.dctx, state.chunk, state.chunk_bytes, + offset * typesize, wanted, + destination + done * typesize, wanted) + if rc != wanted: + return 1 + done += take + state.maximum_items = max(state.maximum_items, count) + state.read_bytes += capacity + return 0 + +cdef object array_view_binding(np.ndarray array, b2_array_view *view): + cdef np.ndarray root + cdef object owner = array + cdef object base + cdef int i + # Follow ndarray/DummyArray owners; bounds are the allocation, never an + # as_strided view's possibly fictitious logical byte extent. + while getattr(owner, "base", None) is not None: + owner = owner.base + if not isinstance(owner, np.ndarray): + try: + owner = np.frombuffer(owner, dtype=np.uint8) + except (TypeError, ValueError, BufferError): + array = np.array(array, copy=True, order="K") + owner = array + elif not owner.flags.owndata: + array = np.array(array, copy=True, order="K") + owner = array + root = owner + if array.ndim > 16: + raise ValueError("Native logical arrays support at most 16 axes") + view.dtype = _me_dtype_from_numpy_dtype(array.dtype.newbyteorder('=')) + view.base = np.PyArray_DATA(root) + view.capacity = root.nbytes + if np.PyArray_DATA(array) < view.base: + raise ValueError("Array offset precedes owning allocation") + view.offset = np.PyArray_DATA(array) - view.base + view.rank = array.ndim + for i in range(view.rank): + view.shape[i] = array.shape[i] + view.strides[i] = array.strides[i] + view.byte_order = 1 if array.dtype.byteorder == '<' else 2 if array.dtype.byteorder == '>' else 0 + return array + + +cdef extern from "dsl_graph_bridge.h": + ctypedef void (*b2_graph_task_fn)(void *, size_t) noexcept nogil + ctypedef int (*b2_graph_fork_join_fn)(void *, size_t, b2_graph_task_fn, void *) noexcept nogil + int b2_graph_native_executor_available() + int b2_graph_native_fork_join(void *, size_t, b2_graph_task_fn, void *) noexcept nogil + unsigned b2_graph_execution_capabilities(const void *) nogil + int b2_graph_execute_parallel_into(const void *, const b2_array_view *, int, + const b2_array_view *, unsigned, size_t, b2_graph_fork_join_fn, void *, + b2_graph_report *, b2_graph_error *) nogil + int b2_graph_output_available() nogil + int b2_graph_execute_into(const void *, const b2_array_view *, const b2_array_source *, int, + const b2_array_view *, unsigned, b2_graph_report *, b2_graph_error *) nogil + ctypedef struct b2_graph_metadata: + const char *name + me_dtype dtype + int rank + int64_t shape[16] + ctypedef struct b2_graph_error: + int node + int stage + b2_artifact_error native + ctypedef struct b2_graph_report: + b2_array_report array + size_t stages + size_t jit_stages + size_t interpreter_stages + size_t tasks + int b2_graph_prepare(const char *, size_t, int, int, void **, b2_graph_error *) nogil + int b2_graph_prepare_text(const char *, size_t, const b2_graph_metadata *, int, int, int, void **, b2_graph_error *) nogil + int b2_graph_specialize(const void *, const b2_graph_metadata *, int, size_t, size_t, void **, b2_graph_error *) nogil + int b2_graph_execute(const void *, const b2_array_view *, int, void *, size_t, unsigned, b2_graph_report *, b2_graph_error *) nogil + int b2_graph_sources_available() + int b2_graph_execute_sources(const void *, const b2_array_source *, int, void *, size_t, unsigned, b2_graph_report *, b2_graph_error *) nogil + void b2_graph_free(void *) + void b2_graph_schedule_free(void *) + int b2_graph_ninputs(const void *) + const char *b2_graph_name(const void *, int) + me_dtype b2_graph_dtype(const void *, int) + me_dtype b2_graph_inferred(const void *) + int b2_graph_jit(const void *) + const char *b2_graph_reduction_op(const void *) + int b2_graph_reduction_axis_count(const void *) + int b2_graph_reduction_axis(const void *, int) + int b2_graph_reduction_keepdims(const void *) + int b2_graph_reduction_has_initial(const void *) + int b2_graph_reduction_has_where(const void *) + const char *b2_graph_json(const void *) + const char *b2_graph_map_json(const void *) + const void *b2_graph_map_artifact(const void *) + size_t b2_graph_stages(const void *) + size_t b2_graph_intermediate(const void *) + size_t b2_graph_plan_bytes(const void *) + size_t b2_graph_schedule_bytes(const void *) + size_t b2_graph_scratch(const void *) + int b2_graph_stage_info(const void *, int, int64_t *, me_dtype *, size_t *, int *) + int b2_graph_shape(const void *, int64_t *, me_dtype *) + int b2_graph_map_shape(const void *, int64_t *) + + +cdef void raise_graph_error(int rc, b2_graph_error *error, b2_array_report *report=NULL) except *: + if rc == -100: + raise NotImplementedError("Build with miniexpr native graph preparation support") + if rc == -7: + raise MemoryError((error.native.message).decode("utf-8", "replace")) + from blosc2.portable_kernel import PortableArtifactError + statuses = {-1: "invalid_graph", -2: "unsupported_requirement", -3: "invalid_signature", + -4: "shape_error", -5: "binding_error", -6: "evaluation_error", -8: "unavailable_capability"} + exception = PortableArtifactError( + f"{(error.native.message).decode('utf-8', 'replace')} (node={error.node}, stage={error.stage})", + status=statuses.get(rc, "native_error"), native_status=error.native.native_status, + line=error.native.line, column=error.native.column) + exception.node = error.node + exception.stage = error.stage + if report != NULL: + exception.fp_status = {"flags": report.fp_flags, "supported": bool(report.fp_supported)} + raise exception + + +cdef class _GraphHostInvocation: + cdef bint closed + cdef size_t active + cdef object waiter + + +def _execute_graph_host_task(uintptr_t callback, uintptr_t invocation, size_t index, + _GraphHostInvocation state): + cdef b2_graph_task_fn task = callback + if state.closed: + return + state.active += 1 + try: + with nogil: + task(invocation,index) + finally: + state.active -= 1 + if not state.active and state.closed: + state.waiter.set() + + +cdef int graph_host_fork_join(void *host, size_t count, b2_graph_task_fn task, void *invocation) noexcept with gil: + cdef _GraphHostInvocation state = None + futures = [] + try: + from threading import Event + state = _GraphHostInvocation() + state.waiter = Event() # Allocate join state before any job can be enqueued. + from .resident_execution import resident_pool + for index in range(count - 1): + futures.append(resident_pool().submit(_execute_graph_host_task, + task,invocation,index,state)) + # The synchronous caller is a worker too. This removes one pool + # submission and avoids idling it while short native tasks run. + with nogil: + task(invocation,count - 1) + except BaseException as error: + if state is not None: + state.closed = True + (host).append(error) + finally: + # result() is an inexpensive join when caller work let the future finish. + # Join every started task even after submission/worker failures or an + # interrupted wait: native invocation pointers must not outlive this call. + for future in futures: + while True: + try: + future.result() + break + except BaseException as error: + state.closed = True + (host).append(error) + if future.done(): + break + # submit() can enqueue work and THEN fail while starting a thread. Such + # a task has no returned Future. Close its gate before freeing native + # state; join any native calls already entered, and let late jobs skip. + if state is not None: + state.closed = True + while state.active: + try: + state.waiter.wait() + except BaseException as error: + (host).append(error) + return 1 if host else 0 + + +def native_graph_output_available(): + return bool(b2_graph_output_available()) + + +def native_graph_executor_available(): + return bool(b2_graph_native_executor_available()) + + +def native_graph_sources_available(): + return bool(b2_graph_sources_available()) + + +cdef class NativeGraphHandle: + cdef void *_handle + + def __cinit__(self, graph=None, int jit_mode=2, bint require_jit=False): + cdef b2_graph_error error + cdef bytes encoded + cdef const char *json + cdef size_t size + cdef int rc + self._handle = NULL + if graph is None: + return + encoded = graph + json = encoded + size = len(encoded) + with nogil: + rc = b2_graph_prepare(json, size, jit_mode, require_jit, &self._handle, &error) + if rc: + raise_graph_error(rc, &error) + + def __dealloc__(self): + b2_graph_free(self._handle) + + def info(self): + cdef int i + if self._handle == NULL: + raise ValueError("Uninitialized graph handle") + return {"inputs": {(b2_graph_name(self._handle, i)).decode('utf-8'): + _numpy_dtype_from_me_dtype(b2_graph_dtype(self._handle, i)) + for i in range(b2_graph_ninputs(self._handle))}, + "inferred_dtype": _numpy_dtype_from_me_dtype(b2_graph_inferred(self._handle)), + "has_jit": bool(b2_graph_jit(self._handle)), "stages": b2_graph_stages(self._handle), + "plan_metadata_bytes": b2_graph_plan_bytes(self._handle), + "partitionable": bool(b2_graph_execution_capabilities(self._handle) & 1)} + + def reduction_info(self): + """Borrowed root-reduction metadata; None for non-reduction graphs.""" + cdef const char *op + cdef int count, i + if self._handle == NULL: + raise ValueError("Uninitialized graph handle") + op = b2_graph_reduction_op(self._handle) + if op == NULL: + return None + count = b2_graph_reduction_axis_count(self._handle) + axes = None if count < 0 else tuple( + b2_graph_reduction_axis(self._handle, i) for i in range(count) + ) + return { + "op": (op).decode("ascii"), + "axes": axes, + "keepdims": bool(b2_graph_reduction_keepdims(self._handle)), + "initial": bool(b2_graph_reduction_has_initial(self._handle)), + "where": bool(b2_graph_reduction_has_where(self._handle)), + } + + def to_json(self): + if self._handle == NULL: + raise ValueError("Uninitialized graph handle") + return (b2_graph_json(self._handle)).decode('utf-8') + + def map_json(self): + cdef const char *json = b2_graph_map_json(self._handle) + if json == NULL: + raise ValueError("Root reductions/final conversions cannot be exported as elementwise artifacts") + return (json).decode('utf-8') + + def resident_artifact(self): + """Borrow the prepared map artifact, retaining this native plan owner.""" + if self._handle == NULL or b2_graph_map_json(self._handle) == NULL: + return None + cdef const void *artifact = b2_graph_map_artifact(self._handle) + if artifact == NULL: + return None + cdef PortableArtifactHandle result = PortableArtifactHandle() + result._handle = artifact + result._owner = self + return result + + @staticmethod + def from_expression(bytes expression, input_dtypes, int jit_mode=2, bint require_jit=False): + cdef b2_graph_metadata metadata[128] + cdef b2_graph_error error + cdef int n = len(input_dtypes), i, rc + cdef bytes name + cdef list names = [key.encode('utf-8') for key in input_dtypes] + cdef const char *text = expression + cdef size_t length = len(expression) + cdef NativeGraphHandle result = NativeGraphHandle() + if n > 128: + raise ValueError("Native graph binding limit exceeded") + memset(metadata, 0, sizeof(metadata)) + for i, dtype in enumerate(input_dtypes.values()): + name = names[i] + if b'\x00' in name: + raise ValueError("Input names cannot contain NUL") + metadata[i].name = name + metadata[i].dtype = _me_dtype_from_numpy_dtype(np.dtype(dtype).newbyteorder('=')) + with nogil: + rc = b2_graph_prepare_text(text, length, metadata, n, jit_mode, require_jit, &result._handle, &error) + if rc: + raise_graph_error(rc, &error) + return result + + def specialize(self, inputs, size_t tile_items=1024, size_t intermediate_budget=0): + """inputs maps names to (dtype, shape); no buffers or array reads.""" + cdef b2_graph_metadata metadata[128] + cdef b2_graph_error error + cdef int n = len(inputs), i, j, rc + cdef list names = [key.encode('utf-8') for key in inputs] + cdef bytes name + cdef NativeGraphSchedule result = NativeGraphSchedule() + if self._handle == NULL: + raise ValueError("Uninitialized graph handle") + memset(metadata, 0, sizeof(metadata)) + if n > 128: + raise ValueError("Native graph binding limit exceeded") + for i, (dtype, shape) in enumerate(inputs.values()): + name = names[i] + if b'\x00' in name: + raise ValueError("Input names cannot contain NUL") + metadata[i].name = name + metadata[i].dtype = _me_dtype_from_numpy_dtype(np.dtype(dtype).newbyteorder('=')) + metadata[i].rank = len(shape) + if len(shape) > 16: + raise ValueError("Native graph rank limit exceeded") + for j in range(len(shape)): + metadata[i].shape[j] = shape[j] + with nogil: + rc = b2_graph_specialize(self._handle, metadata, n, tile_items, intermediate_budget, &result._handle, &error) + if rc: + raise_graph_error(rc, &error) + return result + + +cdef class NativeGraphSchedule: + cdef void *_handle + + def __cinit__(self): + self._handle = NULL + + def __dealloc__(self): + b2_graph_schedule_free(self._handle) + + def info(self): + cdef int64_t shape[16], domain[16] + cdef me_dtype dtype + cdef int rank = b2_graph_shape(self._handle, shape, &dtype) + cdef int domain_rank = b2_graph_map_shape(self._handle, domain) + if rank < 0: + raise ValueError("Uninitialized graph schedule") + return {"shape": tuple(shape[i] for i in range(rank)), + "map_shape": tuple(domain[i] for i in range(domain_rank)), + "dtype": _numpy_dtype_from_me_dtype(dtype), + "intermediate_bytes": b2_graph_intermediate(self._handle), + "schedule_metadata_bytes": b2_graph_schedule_bytes(self._handle), + "iterator_scratch_bound": b2_graph_scratch(self._handle)} + + def stage_info(self, int stage): + cdef int64_t shape[16] + cdef me_dtype dtype + cdef size_t capacity + cdef int last + cdef int rank = b2_graph_stage_info(self._handle, stage, shape, &dtype, &capacity, &last) + if rank < 0: + raise ValueError("Invalid stage or unavailable stage descriptions") + return {"shape": tuple(shape[i] for i in range(rank)), "dtype": _numpy_dtype_from_me_dtype(dtype), + "bytes": capacity, "last_consumer": last} + + def execute(self, inputs, unsigned raise_mask=0, *, out=None, size_t workers=1): + cdef b2_array_view views[128] + cdef b2_array_view destination + cdef b2_graph_report report + cdef b2_graph_error error + cdef int n = len(inputs), i, rc + cdef list names = [key.encode('utf-8') for key in inputs] + cdef list owned = [] + cdef list executor_errors = [] + cdef bytes name + cdef np.ndarray array, bound, output + cdef size_t normalized = 0, capacity + cdef b2_graph_fork_join_fn executor = graph_host_fork_join + if workers > 1 and native_graph_executor_available(): + executor = b2_graph_native_fork_join + if n > 128: + raise ValueError("Native graph binding limit exceeded") + memset(views, 0, sizeof(views)) + memset(&report,0,sizeof(report)) + info = self.info() + output = np.empty(info['shape'], dtype=info['dtype']) if out is None else out + if (output).shape != info['shape'] or output.dtype != info['dtype']: + raise ValueError("Graph output shape/dtype disagree with schedule") + if not output.flags.writeable or not output.flags.aligned or not output.dtype.isnative: + raise ValueError("Graph output must be writable, aligned and native-endian") + if out is not None or workers > 1: + if not b2_graph_output_available(): + raise NotImplementedError("Build with native destination descriptor support") + memset(&destination,0,sizeof(destination)) + if array_view_binding(output,&destination) is not output: + raise ValueError("Cannot establish output allocation bounds") + capacity = output.nbytes + for i, value in enumerate(inputs.values()): + if not isinstance(value, np.ndarray): + raise TypeError("Graph execution requires explicit NumPy buffers") + array = value + bound = array_view_binding(array, &views[i]) + if bound is not array: + normalized += bound.nbytes + owned.append(bound) + name = names[i] + if b'\x00' in name: + raise ValueError("Input names cannot contain NUL") + views[i].name = name + with nogil: + if workers > 1: + rc = b2_graph_execute_parallel_into(self._handle,views,n,&destination,raise_mask,workers, + executor,executor_errors,&report,&error) + elif out is None: + rc = b2_graph_execute(self._handle, views, n, np.PyArray_DATA(output), capacity, + raise_mask, &report, &error) + else: + rc = b2_graph_execute_into(self._handle,views,NULL,n,&destination,raise_mask,&report,&error) + if executor_errors: + raise executor_errors[0] + if rc: + raise_graph_error(rc, &error, &report.array) + return output, {"temporary_bytes": report.array.temporary_bytes, "gathered_bytes": report.array.gathered_bytes, + "normalization_bytes": normalized, "zero_copy_tiles": report.array.zero_copy_tiles, + "evaluated_tiles": report.array.evaluated_tiles, "fp_flags": report.array.fp_flags, + "fp_supported": bool(report.array.fp_supported), "stages": report.stages, + "jit_stages": report.jit_stages, "interpreter_stages": report.interpreter_stages, + "intermediate_bytes": b2_graph_intermediate(self._handle), + "tasks": report.tasks or 1} + + def execute_sources(self, inputs, readers, unsigned raise_mask=0, *, bint native_spans=False, out=None): + """Bind invocation-local metadata readers; native traversal owns all requests.""" + cdef b2_array_source sources[128] + cdef graph_span_reader_state spans[128] + cdef int n = len(inputs), i + cdef list names = [key.encode('utf-8') for key in inputs] + cdef list owned = [], states = [] + cdef np.ndarray output + if not b2_graph_sources_available(): + raise NotImplementedError("Native runtime does not support graph storage readers") + if n > 128 or set(readers) - set(inputs): + raise ValueError("Invalid graph storage-reader bindings") + memset(sources, 0, sizeof(sources)) + memset(spans, 0, sizeof(spans)) + info = self.info() + if out is None: + output = np.empty(info['shape'], dtype=info['dtype']) + else: + if not isinstance(out, np.ndarray): + raise TypeError("Graph output requires a NumPy array") + output = out + if out.shape != info['shape'] or out.dtype != info['dtype']: + raise ValueError("Graph output shape/dtype disagree with schedule") + if (not output.flags.aligned or not output.flags.writeable or not output.dtype.isnative + or (not output.flags.c_contiguous and not b2_graph_output_available())): + raise ValueError("Graph output must be writable, aligned and supported by the runtime") + if any(isinstance(value, np.ndarray) and np.shares_memory(output, value) for value in inputs.values()): + raise ValueError("Graph output must not overlap resident inputs") + try: + return self._execute_sources_bound(inputs, readers, raise_mask, native_spans, + sources, spans, names, owned, states, output) + finally: + for i in range(n): + if spans[i].dctx != NULL: + blosc2_free_ctx(spans[i].dctx) + if spans[i].needs_free: + free(spans[i].chunk) + + cdef object _execute_sources_bound(self, object inputs, object readers, unsigned raise_mask, + bint native_spans, b2_array_source *sources, + graph_span_reader_state *spans, list names, list owned, + list states, np.ndarray output): + cdef b2_graph_report report + cdef b2_graph_error error + cdef int n = len(inputs), i, j, rc + cdef b2_array_view destination + cdef bytes name + cdef object state, value + cdef np.ndarray array, bound + cdef size_t normalized = 0, capacity = output.nbytes + cdef blosc2_dparams dparams + cdef NDArray compressed + memset(&destination,0,sizeof(destination)) + if b2_graph_output_available() and array_view_binding(output,&destination) is not output: + raise ValueError("Cannot establish output allocation bounds") + for i, (key, value) in enumerate(inputs.items()): + name = names[i] + if b'\x00' in name: + raise ValueError("Input names cannot contain NUL") + if key in readers: + state = readers[key] + states.append(state) + sources[i].view.dtype = _me_dtype_from_numpy_dtype(state.dtype) + sources[i].view.rank = len(state.reader.shape) + if sources[i].view.rank > 16: + raise ValueError("Storage reader rank limit exceeded") + for j in range(sources[i].view.rank): + sources[i].view.shape[j] = state.reader.shape[j] + sources[i].read = storage_reader_callback + sources[i].owner = state + if native_spans: + if not isinstance(value, NDArray) or sources[i].view.rank != 1: + raise ValueError("Native span readers require 1-D compressed arrays") + compressed = value + if compressed.ndim != 1: + raise ValueError("Native span readers require 1-D compressed arrays") + spans[i].array = compressed.array + spans[i].origin = state.reader.start + spans[i].extent = state.reader.shape[0] + if spans[i].origin < 0 or spans[i].extent < 0 or spans[i].origin + spans[i].extent > compressed.array.shape[0]: + raise ValueError("Native span reader extent exceeds input shape") + dparams = compressed.array.sc.storage.dparams[0] + dparams.nthreads = 1 + dparams.schunk = compressed.array.sc + dparams.typesize = compressed.array.sc.typesize + spans[i].dctx = blosc2_create_dctx(dparams) + if spans[i].dctx == NULL: + raise MemoryError("Cannot allocate native graph decoder") + sources[i].read = graph_span_reader_callback + sources[i].owner = &spans[i] + else: + if not isinstance(value, np.ndarray): + raise TypeError("Resident graph inputs require NumPy buffers") + array = value + bound = array_view_binding(array, &sources[i].view) + if bound is not array: + normalized += bound.nbytes + owned.append(bound) + sources[i].view.name = name + with nogil: + if b2_graph_output_available(): + rc = b2_graph_execute_into(self._handle,NULL,sources,n,&destination,raise_mask,&report,&error) + else: + rc = b2_graph_execute_sources(self._handle, sources, n, np.PyArray_DATA(output), capacity, + raise_mask, &report, &error) + for state in states: + if state.error is not None: + raise state.error + if rc: + raise_graph_error(rc, &error, &report.array) + return output, {"temporary_bytes": report.array.temporary_bytes, + "gathered_bytes": report.array.gathered_bytes, "normalization_bytes": normalized, + "zero_copy_tiles": report.array.zero_copy_tiles, "evaluated_tiles": report.array.evaluated_tiles, + "fp_flags": report.array.fp_flags, "fp_supported": bool(report.array.fp_supported), + "stages": report.stages, "jit_stages": report.jit_stages, + "interpreter_stages": report.interpreter_stages, + "intermediate_bytes": b2_graph_intermediate(self._handle), + "maximum_reader_items": max(max((state.max_items for state in states), default=0), + max((spans[i].maximum_items for i in range(n)), default=0)), + "reader_bytes": sum(state.read_bytes for state in states) + sum(spans[i].read_bytes for i in range(n)), + "native_decoder_contexts": sum(spans[i].dctx != NULL for i in range(n)), + "input_materialization_bytes": 0} + + +def portable_artifact_available(): + return bool(b2_artifact_available()) + + +def portable_auto_jit_mode(): + return b2_artifact_auto_jit_mode() + + +def portable_descriptor_available(): + return bool(b2_artifact_descriptor_available()) + + +cdef void raise_artifact_error(int rc, b2_artifact_error *error) except *: + from blosc2.portable_kernel import PortableArtifactError + + if rc == -100: + raise NotImplementedError("Build with miniexpr portable artifact support") + if rc == -6: + raise MemoryError((error.message).decode("utf-8", "replace")) + statuses = {-1: "invalid_artifact", -2: "unsupported_requirement", -3: "invalid_source", + -4: "binding_error", -5: "evaluation_error"} + raise PortableArtifactError( + (error.message).decode("utf-8", "replace"), + status=statuses.get(rc, "native_error"), native_status=error.native_status, + line=error.line, column=error.column) + + +cdef class PortableArtifactHandle: + """Owned immutable native handle; no Python artifact decoding or source execution.""" + cdef void *_handle + cdef object _owner + + def __cinit__(self, bytes artifact=None, int jit_mode=0, bint infer_output=False): + cdef b2_artifact_error error + cdef int rc + cdef const char *json + cdef size_t size + cdef me_jit_options native_options + options = blosc2.jit_config.execution_options() + cdef bytes compiler = (options["compiler"] or "").encode() + cdef bytes flags = (options["cflags"] or "").encode() + cdef bytes cache = (options["cache_dir"] or "").encode() + native_options.compiler = compiler if compiler else NULL + native_options.cflags = flags if flags else NULL + native_options.cache_dir = cache if cache else NULL + native_options.trace = int(options["trace"]) + native_options.compiler_output = int(options["compiler_output"]) + self._handle = NULL + if artifact is None: + return + json = artifact + size = len(artifact) + if infer_output and not b2_artifact_load_inferred_available(): + raise NotImplementedError( + "Build with miniexpr inferred-output artifact support" + ) + with nogil: + if infer_output: + rc = b2_artifact_load_inferred(json, size, jit_mode, &native_options, &self._handle, &error) + else: + rc = b2_artifact_load_options(json, size, jit_mode, &native_options, &self._handle, &error) + if rc: + raise_artifact_error(rc, &error) + + def __dealloc__(self): + if self._owner is None: + b2_artifact_free(self._handle) + + def info(self): + cdef int i + return { + "source": (b2_artifact_source(self._handle)).decode("utf-8"), + "entry_point": (b2_artifact_entry(self._handle)).decode("utf-8"), + "inputs": {(b2_artifact_name(self._handle, i)).decode("utf-8"): + _numpy_dtype_from_me_dtype(b2_artifact_dtype(self._handle, i)) + for i in range(b2_artifact_ninputs(self._handle))}, + "output_dtype": _numpy_dtype_from_me_dtype(b2_artifact_output(self._handle)), + "jit": bool(b2_artifact_jit(self._handle)), + "execution_kind": (b2_artifact_execution_kind(self._handle)).decode("ascii"), + "math_backend": (b2_artifact_math(self._handle)).decode("ascii"), + "sleef_accuracy": (b2_artifact_math_ulp(self._handle)).decode("ascii"), + "fp_mode": (b2_artifact_fp(self._handle)).decode("ascii"), + } + + cdef object signature_dtype(self, int index): + cdef me_dtype dtype = b2_artifact_output(self._handle) if index < 0 else b2_artifact_dtype(self._handle, index) + cdef size_t width = b2_artifact_width(self._handle, index) + if dtype == ME_STRING: + return np.dtype(f"U{width // 4}") + if dtype == ME_BYTES: + return np.dtype(f"S{width}") + return _numpy_dtype_from_me_dtype(dtype) + + def descriptor_info(self): + """Authoritative draft native signature; unavailable on older pinned builds.""" + if not b2_artifact_descriptor_available(): + raise NotImplementedError("Build with draft miniexpr descriptor support") + return { + "schema_version": (b2_artifact_version(self._handle)).decode("ascii"), + "inputs": {(b2_artifact_name(self._handle, i)).decode("utf-8"): + self.signature_dtype(i) for i in range(b2_artifact_ninputs(self._handle))}, + "output_dtype": self.signature_dtype(-1), + "inferred_dtype": (None if b2_artifact_inferred(self._handle) == ME_AUTO else + _numpy_dtype_from_me_dtype(b2_artifact_inferred(self._handle))), + "cardinality": "block_scalar" if b2_artifact_cardinality(self._handle) == 1 else "elementwise", + "ndim": b2_artifact_rank(self._handle), + "math_backend": (b2_artifact_math(self._handle)).decode("ascii"), + "sleef_accuracy": (b2_artifact_math_ulp(self._handle)).decode("ascii"), + "fp_mode": (b2_artifact_fp(self._handle)).decode("ascii"), + } + + def evaluate_block(self, inputs, block_shape, *, logical_shape=None, block_origin=None, valid_mask=None, + bint return_status=False, unsigned fp_raise=0, _output=None): + """Evaluate one explicit logical block; never infer ND coordinates from a physical tile.""" + cdef b2_artifact_fp_status fp_status + from math import prod + + if not b2_artifact_descriptor_available(): + raise NotImplementedError("Build with draft miniexpr descriptor support") + cdef Py_ssize_t n = len(inputs), i + if n > 128: + raise ValueError("Too many portable artifact inputs") + block_shape = tuple(block_shape) + if any(type(size) is not int or size < 0 for size in block_shape): + raise ValueError("Block shape must contain nonnegative Python integers") + count = prod(block_shape) + if count > 2147483647: + raise ValueError("Native block exceeds the supported lane count") + cdef b2_artifact_buffer *bindings = NULL + cdef b2_artifact_descriptor descriptor + cdef b2_artifact_error error + cdef np.ndarray array, output, mask, shape_array, origin_array, extent_array + cdef list names = [key.encode("utf-8") for key in inputs] + cdef list arrays = list(inputs.values()) + cdef bytes name + cdef int rc + memset(&descriptor, 0, sizeof(descriptor)) + descriptor.struct_size = sizeof(descriptor) + descriptor.version = 1 + descriptor.nitems = count + descriptor.ndim = b2_artifact_rank(self._handle) + if descriptor.ndim: + if logical_shape is None or block_origin is None or len(block_shape) != descriptor.ndim: + raise ValueError("Explicit logical shape, block origin and matching block rank are required") + shape_array = np.ascontiguousarray(logical_shape, dtype=np.int64) + origin_array = np.ascontiguousarray(block_origin, dtype=np.int64) + extent_array = np.ascontiguousarray(block_shape, dtype=np.int64) + if shape_array.ndim != 1 or origin_array.ndim != 1 or shape_array.shape[0] != descriptor.ndim or origin_array.shape[0] != descriptor.ndim: + raise ValueError("Logical context rank mismatch") + descriptor.logical_shape = np.PyArray_DATA(shape_array) + descriptor.block_origin = np.PyArray_DATA(origin_array) + descriptor.block_extent = np.PyArray_DATA(extent_array) + elif logical_shape is not None or block_origin is not None: + raise ValueError("This artifact does not declare ND context") + if valid_mask is not None: + mask = np.asarray(valid_mask) + if mask.dtype not in (np.dtype(np.bool_), np.dtype(np.uint8)) or mask.size != count: + raise ValueError("Valid mask must have one Boolean/uint8 slot per block lane") + mask = np.ascontiguousarray(mask, dtype=np.uint8) + descriptor.valid_mask = np.PyArray_DATA(mask) + descriptor.valid_mask_capacity = mask.nbytes + output_shape = () if b2_artifact_cardinality(self._handle) == 1 else block_shape + output = (np.empty(output_shape, dtype=self.signature_dtype(-1)) + if _output is None else _output) + if ((output).shape != output_shape or output.dtype != self.signature_dtype(-1) + or not output.flags.c_contiguous or not output.flags.aligned + or not output.flags.writeable): + raise ValueError("Output must be writable, aligned, contiguous and match the result signature") + if _output is not None and any(np.shares_memory(output, value) for value in arrays): + raise ValueError("Portable block output must not alias inputs") + descriptor.output_capacity = output.nbytes + if n: + bindings = calloc(n, sizeof(b2_artifact_buffer)) + if bindings == NULL: + raise MemoryError() + try: + for i in range(n): + array = arrays[i] + if not array.flags.c_contiguous or not array.flags.aligned or not array.dtype.isnative or array.size != count: + raise ValueError("Block inputs must be aligned, contiguous, host-endian and match the block extent") + name = names[i] + if b'\x00' in name: + raise ValueError("Input names must not contain NUL") + bindings[i].name = name + bindings[i].dtype = _me_dtype_from_numpy_dtype(array.dtype) + bindings[i].itemsize = array.dtype.itemsize + bindings[i].data = np.PyArray_DATA(array) + bindings[i].capacity = array.nbytes + with nogil: + if return_status or fp_raise: + rc = b2_artifact_eval_status(self._handle, bindings, n, np.PyArray_DATA(output), &descriptor, fp_raise, &fp_status, &error) + else: + rc = b2_artifact_eval_ex(self._handle, bindings, n, np.PyArray_DATA(output), &descriptor, &error) + if rc: + try: + raise_artifact_error(rc, &error) + except Exception as exc: + if return_status or fp_raise: + exc.fp_status = {"flags": fp_status.flags, "supported": bool(fp_status.supported)} + raise + return (output, {"flags": fp_status.flags, "supported": bool(fp_status.supported)}) if return_status else output + finally: + free(bindings) + + def evaluate_array(self, inputs, shape, reduction=None, axes=None, bint keepdims=False, + accumulator=None, initial=None, where=None, size_t tile_items=1024): + cdef b2_array_view *views = NULL + cdef b2_array_view mask_view + cdef b2_array_options options + cdef b2_array_report report + cdef b2_artifact_error error + cdef int64_t domain[16] + cdef int64_t result_shape[16] + cdef int rank = len(shape), result_rank, rc, n = len(inputs), i, j + cdef me_dtype result_dtype + cdef size_t output_bytes + cdef np.ndarray array, output, initial_array + cdef bytes name + cdef list names = [value.encode('utf-8') for value in inputs] + cdef list owned = [] + cdef size_t normalization_bytes = 0 + cdef np.ndarray bound + memset(&options, 0, sizeof(options)) + memset(&error, 0, sizeof(error)) + if rank > 16 or n > 128: + raise ValueError("Native array rank/input limit exceeded") + for i in range(rank): + domain[i] = shape[i] + options.version = 1 + options.reduction = {None: 0, 'sum': 1, 'prod': 2, 'min': 3, 'max': 4, 'any': 5, 'all': 6}[reduction] + options.naxes = 0 if reduction is None else -1 if axes is None else len(axes) + if options.naxes > 16: + raise ValueError("Too many reduction axes") + if axes is not None: + for i in range(options.naxes): + options.axes[i] = axes[i] + options.keepdims = keepdims + options.accumulator = ME_AUTO if accumulator is None else _me_dtype_from_numpy_dtype(np.dtype(accumulator)) + options.tile_items = tile_items + with nogil: + rc = b2_array_shape(self._handle, rank, domain, &options, &result_rank, result_shape, &result_dtype, &error) + if rc: + raise_artifact_error(rc, &error) + output = np.empty(tuple(result_shape[i] for i in range(result_rank)), dtype=_numpy_dtype_from_me_dtype(result_dtype)) + output_bytes = output.nbytes + if initial is not None: + initial_array = np.asarray(initial, dtype=output.dtype) + if initial_array.ndim != 0: + raise ValueError("initial must be a scalar") + options.initial = np.PyArray_DATA(initial_array) + if where is not None: + array = np.asarray(where) + if array.dtype != np.dtype('bool'): + raise TypeError("Participating mask must have bool dtype") + bound = array_view_binding(array, &mask_view) + if bound is not array: + normalization_bytes += bound.nbytes + owned.append(bound) + options.where = &mask_view + if n: + views = calloc(n, sizeof(b2_array_view)) + if views == NULL: + raise MemoryError() + try: + for i, value in enumerate(inputs.values()): + array = np.asarray(value) + bound = array_view_binding(array, &views[i]) + if bound is not array: + normalization_bytes += bound.nbytes + owned.append(bound) + name = names[i] + if b'\x00' in name: + raise ValueError("Input names cannot contain NUL") + views[i].name = name + with nogil: + rc = b2_array_eval(self._handle, views, n, rank, domain, &options, + np.PyArray_DATA(output), output_bytes, &report, &error) + if rc: + raise_artifact_error(rc, &error) + return output, {"temporary_bytes": report.temporary_bytes, "gathered_bytes": report.gathered_bytes, + "normalization_bytes": normalization_bytes, + "zero_copy_tiles": report.zero_copy_tiles, "evaluated_tiles": report.evaluated_tiles, + "fp_flags": report.fp_flags, "fp_supported": bool(report.fp_supported)} + finally: + free(views) + + def evaluate_prefilter(self, inputs, out=None, numpy_out=None, _chunk_range=None, + _driver_input=None, _nthreads=None, _block_items=None, _diagonal=None): + """Run an artifact through C-Blosc2 scheduling into Blosc2 or NumPy.""" + if not portable_prefilter_inputs_eligible( + inputs, allow_numpy=numpy_out is not None or out is not None, output=out): + raise NotImplementedError("Inputs are not eligible for portable prefilter execution") + signature = self.descriptor_info() + if set(inputs) != set(signature["inputs"]): + raise ValueError("Portable prefilter input names disagree with signature") + if (signature["cardinality"] != "elementwise" + or signature["ndim"] not in (0, (out.ndim if not inputs and out is not None else 1))): + raise ValueError("Portable prefilters require matching-rank elementwise kernels") + if any(value.dtype != signature["inputs"][name] for name, value in inputs.items()): + raise TypeError("Portable prefilter input dtype disagrees with signature") + first = next((value for value in inputs.values() if isinstance(value, NDArray)), out) + if first is None: + raise ValueError("An output NDArray is required to schedule an input-free prefilter") + if first.ndim > 1 and numpy_out is not None: + raise ValueError("N-D portable prefilters require an NDArray output") + if _diagonal is not None and (inputs or first.ndim != 2 or out is None): + raise ValueError("Diagonal scheduling requires input-free 2-D NDArray output") + block_items = first.blocks[0] + if _block_items is not None: + if (numpy_out is None or out is not None or _block_items <= 0 + or first.chunks[0] % _block_items or _block_items % block_items): + raise ValueError("Invalid NumPy prefilter batch layout") + block_items = _block_items + block_bytes = sum(block_items * value.dtype.itemsize for value in inputs.values() + if isinstance(value, NDArray)) + threads = (max(1, min(blosc2.nthreads, (32 * 1024**2) // block_bytes)) + if block_bytes else blosc2.nthreads) + if _nthreads is not None: + if numpy_out is None or not 1 <= _nthreads <= threads: + raise ValueError("Invalid NumPy prefilter thread count") + threads = _nthreads + if _chunk_range is not None: + if numpy_out is None or out is not None: + raise ValueError("Prefilter chunk ranges require a direct NumPy output") + begin, end = _chunk_range + if not 0 <= begin < end <= first.schunk.nchunks: + raise ValueError("Invalid prefilter chunk range") + threads = 1 + if out is None and numpy_out is None: + numpy_out = np.empty(first.shape, dtype=self.signature_dtype(-1)) + if numpy_out is not None: + if out is not None: + raise ValueError("Cannot specify both Blosc2 and NumPy prefilter outputs") + if (type(numpy_out) is not np.ndarray or numpy_out.shape != first.shape + or numpy_out.dtype != self.signature_dtype(-1)): + raise ValueError("NumPy prefilter output must match the input shape and result dtype") + if (not numpy_out.flags.c_contiguous or not numpy_out.flags.aligned + or not numpy_out.flags.writeable): + raise ValueError("NumPy prefilter output must be writable, aligned and C-contiguous") + if any(type(value) is np.ndarray and np.shares_memory(numpy_out, value) + for value in inputs.values()): + raise ValueError("NumPy prefilter output must not overlap an input") + if _driver_input is not None: + if (numpy_out is None or type(_driver_input) is not np.ndarray + or _driver_input.dtype != np.dtype("uint8") + or not _driver_input.flags.c_contiguous + or _driver_input.nbytes != first.chunks[0] * self.signature_dtype(-1).itemsize): + raise ValueError("Invalid shared prefilter driver buffer") + if out is None: + # Only a scheduling context is needed: no full-domain placeholder + # container and no result chunks are stored for a NumPy sink. + output = blosc2.uninit(first.chunks, dtype=self.signature_dtype(-1), + chunks=first.chunks, blocks=(block_items,), + cparams=blosc2.CParams(clevel=1, nthreads=threads)) + if _chunk_range is None: + _chunk_range = (0, first.schunk.nchunks) + else: + if (type(out) is not blosc2.NDArray or out.shape != first.shape + or out.dtype != self.signature_dtype(-1) + or out.chunks != first.chunks or out.blocks != first.blocks): + raise ValueError("Portable prefilter output must match the input grid and result dtype") + if any(out is source for source in inputs.values()): + raise ValueError("Portable prefilter output must not alias an input") + output = out + return output._execute_portable_prefilter(self, inputs, numpy_out=numpy_out, chunk_range=_chunk_range, + driver_input=_driver_input, diagonal=_diagonal) + + def evaluate_sources(self, inputs, readers, shape, size_t tile_items=65536): + cdef b2_array_source *sources = NULL + cdef b2_array_options options + cdef b2_array_report report + cdef b2_artifact_error error + cdef int64_t domain[16] + cdef int64_t result_shape[16] + cdef int rank = len(shape), result_rank, rc, n = len(inputs), i, j + cdef me_dtype result_dtype + cdef size_t output_bytes + cdef np.ndarray array, bound, output + cdef bytes name + cdef object state, value + cdef list names = [key.encode('utf-8') for key in inputs] + cdef list owned = [] + cdef list states = [] + if not b2_array_sources_available(): + raise NotImplementedError("Native runtime does not support storage readers") + if rank > 16 or n > 128 or tile_items == 0 or tile_items > 2147483647: + raise ValueError("Invalid storage-reader rank, input count or tile size") + memset(&options, 0, sizeof(options)) + options.version = 1 + options.tile_items = tile_items + for i in range(rank): + domain[i] = shape[i] + with nogil: + rc = b2_array_shape(self._handle, rank, domain, &options, &result_rank, result_shape, &result_dtype, &error) + if rc: + raise_artifact_error(rc, &error) + output = np.empty(tuple(result_shape[i] for i in range(result_rank)), dtype=_numpy_dtype_from_me_dtype(result_dtype)) + output_bytes = output.nbytes + if n: + sources = calloc(n, sizeof(b2_array_source)) + if sources == NULL: + raise MemoryError() + try: + for i, (key, value) in enumerate(inputs.items()): + name = names[i] + if b'\x00' in name: + raise ValueError("Input names cannot contain NUL") + if key in readers: + state = readers[key] + states.append(state) + sources[i].view.dtype = _me_dtype_from_numpy_dtype(state.dtype) + sources[i].view.rank = len(state.reader.shape) + if sources[i].view.rank > 16: + raise ValueError("Storage reader rank limit exceeded") + for j in range(sources[i].view.rank): + sources[i].view.shape[j] = state.reader.shape[j] + sources[i].read = storage_reader_callback + sources[i].owner = state + else: + array = np.asarray(value) + bound = array_view_binding(array, &sources[i].view) + owned.append(bound) + sources[i].view.name = name + with nogil: + rc = b2_array_eval_sources(self._handle, sources, n, rank, domain, &options, + np.PyArray_DATA(output), output_bytes, &report, &error) + for state in states: + if state.error is not None: + raise state.error + if rc: + raise_artifact_error(rc, &error) + return output, {"temporary_bytes": report.temporary_bytes, + "gathered_bytes": report.gathered_bytes, "evaluated_tiles": report.evaluated_tiles, + "zero_copy_tiles": report.zero_copy_tiles, "fp_flags": report.fp_flags, + "fp_supported": bool(report.fp_supported), "tile_items": tile_items, + "maximum_reader_items": max((state.max_items for state in states), default=0), + "reader_bytes": sum(state.read_bytes for state in states)} + finally: + free(sources) + + def evaluate(self, inputs, shape): + cdef Py_ssize_t n = len(inputs) + if n > 128: + raise ValueError("Too many portable artifact inputs") + cdef b2_artifact_input *bindings = NULL + cdef b2_artifact_error error + cdef np.ndarray array, output + cdef list names = [key.encode("utf-8") for key in inputs] + cdef list arrays = list(inputs.values()) + cdef bytes name + cdef int rc + cdef Py_ssize_t i + cdef size_t count + output = np.empty(shape, dtype=_numpy_dtype_from_me_dtype(b2_artifact_output(self._handle))) + count = output.size + if n: + bindings = calloc(n, sizeof(b2_artifact_input)) + if bindings == NULL: + raise MemoryError() + try: + for i in range(n): + array = arrays[i] + if not array.flags.c_contiguous or not array.flags.aligned or not array.dtype.isnative: + raise ValueError("Native artifact inputs must be aligned, contiguous, and host-endian") + name = names[i] + if b'\x00' in name: + raise ValueError("Input names must not contain NUL") + bindings[i].name = name + bindings[i].dtype = _me_dtype_from_numpy_dtype(array.dtype) + bindings[i].data = np.PyArray_DATA(array) + bindings[i].nitems = array.size + with nogil: + rc = b2_artifact_eval(self._handle, bindings, n, np.PyArray_DATA(output), count, &error) + if rc: + raise_artifact_error(rc, &error) + return output + finally: + free(bindings) + + def me_output_dtype(expression, operands): """Ask miniexpr what dtype *expression* would produce over *operands*. @@ -1011,6 +2601,8 @@ def me_output_dtype(expression, operands): var.itemsize = operand_dtype.itemsize if operand_dtype.num in (18, 19) else 0 built += 1 + from blosc2.utils import canonicalize_miniexpr_functions + expression = canonicalize_miniexpr_functions(expression) expression_bytes = ( (expression).encode("utf-8") if isinstance(expression, str) else expression ) @@ -1081,8 +2673,6 @@ cdef inline str _me_compile_status_name(int rc): return "ME_COMPILE_ERR_PARSE" if rc == ME_COMPILE_ERR_INVALID_ARG: return "ME_COMPILE_ERR_INVALID_ARG" - if rc == ME_COMPILE_ERR_COMPLEX_UNSUPPORTED: - return "ME_COMPILE_ERR_COMPLEX_UNSUPPORTED" if rc == ME_COMPILE_ERR_REDUCTION_INVALID: return "ME_COMPILE_ERR_REDUCTION_INVALID" if rc == ME_COMPILE_ERR_VAR_MIXED: @@ -1302,7 +2892,9 @@ cdef _check_cparams(blosc2_cparams *cparams): if ufilters[i] and cparams.filters[i] in blosc2.ufilters_registry.keys(): raise ValueError("Cannot use multi-threading with user defined Python filters") - if cparams.prefilter != NULL and (cparams.prefilter != miniexpr_prefilter and cparams.prefilter != matmul_prefilter): + if cparams.prefilter != NULL and (cparams.prefilter != miniexpr_prefilter + and cparams.prefilter != matmul_prefilter + and cparams.prefilter != portable_menudet_prefilter): # Note: miniexpr_prefilter uses miniexpr C API which is thread-friendly, raise ValueError("`nthreads` must be 1 when a prefilter is set") @@ -2232,9 +3824,13 @@ cdef class SChunk: cdef Py_buffer chunk_buf PyObject_GetBuffer(chunk_data, &chunk_buf, PyBUF_SIMPLE) self.schunk.current_nchunk = nchunk # prefilter needs this value to be set - cdef int size = blosc2_compress_ctx(self.schunk.cctx, buf.buf, buf.len, chunk_buf.buf, chunk_buf.len) - PyBuffer_Release(&buf) - PyBuffer_Release(&chunk_buf) + cdef int size + try: + with nogil: + size = blosc2_compress_ctx(self.schunk.cctx, buf.buf, buf.len, chunk_buf.buf, chunk_buf.len) + finally: + PyBuffer_Release(&buf) + PyBuffer_Release(&chunk_buf) if size < 0: raise RuntimeError("Could not compress the data") elif size == 0: @@ -2642,7 +4238,7 @@ cdef class SChunk: # postfilter -cdef int general_postfilter(blosc2_postfilter_params *params): +cdef int general_postfilter(blosc2_postfilter_params *params) with gil: cdef user_filters_udata *udata = params.user_data cdef int nd = 1 cdef np.npy_intp dims = params.size // params.typesize @@ -3262,7 +4858,7 @@ cdef int general_udf_prefilter(blosc2_prefilter_params *params): return aux_udf(udata, params.nchunk, params.nblock, False, params.output, params.output_typesize) -cdef int general_udf_postfilter(blosc2_postfilter_params *params): +cdef int general_udf_postfilter(blosc2_postfilter_params *params) with gil: cdef udf_udata *udata = params.user_data return aux_udf(udata, params.nchunk, params.nblock, True, params.output, params.typesize) @@ -3915,13 +5511,15 @@ cdef class NDArray: return arr - def get_1d_span_numpy(self, arr, int64_t nchunk, int32_t start, int32_t nitems): + def get_1d_span_numpy(self, arr, int64_t nchunk, int32_t start, int32_t nitems, int nthreads=0): if self.ndim != 1: raise ValueError("get_1d_span_numpy is only supported for 1-D arrays") if nchunk < 0 or nchunk >= self.array.sc.nchunks: raise IndexError("chunk index out of range") if start < 0 or nitems < 0: raise ValueError("start and nitems must be >= 0") + if nthreads < 0 or nthreads > 32767: + raise ValueError("span nthreads must be between 0 and 32767") if start + nitems > self.array.chunknitems: raise ValueError("requested span exceeds chunk size") @@ -3964,6 +5562,10 @@ cdef class NDArray: # since some codecs/filters resolve per-schunk state (e.g. # dictionaries) through dparams.schunk during decompression. cdef blosc2_dparams dparams = dereference(self.array.sc.storage.dparams) + # Small bounded-reader spans should not repeatedly start large worker + # teams. Zero preserves the existing caller/storage decompression policy. + if nthreads: + dparams.nthreads = nthreads dparams.schunk = self.array.sc dparams.typesize = self.array.sc.typesize dctx = blosc2_create_dctx(dparams) @@ -3979,9 +5581,13 @@ cdef class NDArray: # The getitem entry points need the full lazy chunk size returned by # blosc2_schunk_get_lazychunk(). want_nbytes = nitems * self.array.sc.typesize - rc = blosc2_getitem_bytes_ctx(dctx, chunk, lazychunk_cbytes, - start * self.array.sc.typesize, want_nbytes, - view.buf, view.len) + # This invocation owns its context, chunk reference and destination; + # release the GIL so independent bounded graph readers can decompress + # concurrently instead of serializing all native source callbacks. + with nogil: + rc = blosc2_getitem_bytes_ctx(dctx, chunk, lazychunk_cbytes, + start * self.array.sc.typesize, want_nbytes, + view.buf, view.len) blosc2_free_ctx(dctx) PyBuffer_Release(&view) if needs_free: @@ -4298,7 +5904,7 @@ cdef class NDArray: eval_params.disable_simd = False eval_params.simd_ulp_mode = ME_SIMD_ULP_3_5 if fp_accuracy == blosc2.FPAccuracy.MEDIUM else ME_SIMD_ULP_1 if jit is None: - eval_params.jit_mode = ME_JIT_DEFAULT + eval_params.jit_mode = b2_artifact_auto_jit_mode() elif jit: eval_params.jit_mode = ME_JIT_ON else: @@ -4362,7 +5968,7 @@ cdef class NDArray: cdef blosc2_cparams* cparams = self.array.sc.storage.cparams cparams.prefilter = miniexpr_prefilter - cdef int jit_mode = ME_JIT_DEFAULT + cdef int jit_mode = b2_artifact_auto_jit_mode() if jit is True: jit_mode = ME_JIT_ON elif jit is False: @@ -4410,6 +6016,8 @@ cdef class NDArray: cdef int error = 0 cdef bytes expression_bytes cdef str expression_display + from blosc2.utils import canonicalize_miniexpr_functions + expression = canonicalize_miniexpr_functions(expression) if isinstance(expression, str): expression_display = expression expression_bytes = (expression).encode("utf-8") @@ -4511,6 +6119,8 @@ cdef class NDArray: if backend in ("tcc", "cc"): from blosc2.lazyexpr import _apply_jit_backend_pragma expression = _apply_jit_backend_pragma(expression, inputs, backend) + from blosc2.utils import canonicalize_miniexpr_functions + expression = canonicalize_miniexpr_functions(expression) cdef bytes expression_bytes = ( (expression).encode("utf-8") if isinstance(expression, str) else expression ) @@ -4558,6 +6168,203 @@ cdef class NDArray: if self.array.sc.cctx == NULL: raise RuntimeError("Could not create compression context") + def _portable_chunk_buffer(self): + """Decode one physical chunk without leaking codec floating flags.""" + cdef fenv_t environment + buffer = np.empty(self.array.sc.chunksize // self.dtype.itemsize, dtype=self.dtype) + if feholdexcept(&environment): + raise RuntimeError("Cannot isolate portable chunk decoder floating environment") + try: + self.schunk.decompress_chunk(0, dst=buffer) + finally: + if fesetenv(&environment): + raise RuntimeError("Cannot restore portable chunk decoder floating environment") + return buffer[:self.array.shape[0]] + + def _execute_portable_prefilter(self, PortableArtifactHandle kernel, inputs, + np.ndarray numpy_out=None, chunk_range=None, driver_input=None, + diagonal=None): + cdef portable_prefilter_state state + cdef portable_prefilter_worker *worker + cdef blosc2_prefilter_params parameters + cdef blosc2_cparams *cparams = self.array.sc.storage.cparams + cdef NDArray value + cdef int i, tid, rc + cdef int32_t decoded_bytes, encoded_bytes, block_bytes + cdef size_t decoder_contexts = 0, input_buffer_allocations = 0, input_chunk_fetches = 0 + cdef size_t placeholder_bytes = 0 + cdef int64_t chunk + cdef int64_t begin = 0, end = self.array.sc.nchunks + if chunk_range is not None: + begin, end = chunk_range + memset(&state, 0, sizeof(state)) + memset(¶meters, 0, sizeof(parameters)) + state.artifact = kernel._handle + state.ndim = b2_artifact_rank(kernel._handle) + if diagonal is not None: + state.diagonal_enabled = True + state.diagonal = diagonal + state.ninputs = len(inputs) + state.size = numpy_out.shape[0] if numpy_out is not None else self.array.shape[0] + state.chunk_items = self.array.chunkshape[0] + state.block_items = self.array.blockshape[0] + state.grid_ndim = self.array.ndim + if state.grid_ndim > 1: + state.size = 1 + state.chunk_items = 1 + state.block_items = 1 + for i in range(state.grid_ndim): + state.shape[i] = self.array.shape[i] + state.chunkshape[i] = self.array.chunkshape[i] + state.blockshape[i] = self.array.blockshape[i] + state.chunkgrid[i] = (state.shape[i] + state.chunkshape[i] - 1) // state.chunkshape[i] + state.blockgrid[i] = (state.chunkshape[i] + state.blockshape[i] - 1) // state.blockshape[i] + state.size *= state.shape[i] + state.chunk_items *= state.blockgrid[i] * state.blockshape[i] + state.block_items *= state.blockshape[i] + state.fp_supported = 1 + if numpy_out is not None: + state.numpy_output = numpy_out.data + # All names and source arrays stay owned by kernel/inputs until the + # synchronous compression workers have joined and the context is freed. + for i, (name, source) in enumerate(inputs.items()): + if type(source) is np.ndarray: + state.numpy_inputs[i] = (source).data + else: + value = source + state.inputs[i] = value.array + state.signature[i].name = b2_artifact_name(kernel._handle, i) + # Mapping order may differ from the artifact's signature order. + encoded_name = name.encode("utf-8") + for j in range(state.ninputs): + if encoded_name == b2_artifact_name(kernel._handle, j): + state.signature[i].name = b2_artifact_name(kernel._handle, j) + state.signature[i].dtype = b2_artifact_dtype(kernel._handle, j) + state.signature[i].itemsize = b2_artifact_width(kernel._handle, j) + break + data = (np.empty(self.array.sc.chunksize, dtype=np.uint8) + if driver_input is None else driver_input) + # One block offset plus one zero-run marker per byte stream. Small + # chunks can take Blosc2's memcpy shortcut, so retain at least 128 bytes. + placeholder_capacity = BLOSC2_MAX_OVERHEAD + max( + 128, ((self.array.sc.chunksize + self.array.sc.blocksize - 1) + // self.array.sc.blocksize) * (4 + 4 * self.array.sc.typesize)) + chunk_buffer = (np.empty(placeholder_capacity, dtype=np.uint8) + if numpy_out is not None else None) + state.nworkers = cparams.nthreads + # One compact allocation holds worker records and only the bindings + # actually used by this signature, rather than 128 slots per worker. + state.workers = calloc(state.nworkers, + sizeof(portable_prefilter_worker) + state.ninputs * (sizeof(b2_artifact_buffer) + sizeof(void *))) + if state.workers == NULL: + raise MemoryError() + parameters.user_data = &state + # With clevel=0 keep the memcpy payload without a prefilter memset. + # External NumPy output instead uses clevel=1 and disposable zero-run + # placeholders: the callback skips filters and writes the real sink. + # Never discard the payload of a caller's Blosc2 output. + parameters.output_is_disposable = numpy_out is not None or cparams.clevel == 0 + cparams.prefilter = portable_menudet_prefilter + cparams.preparams = ¶meters + try: + # Active workers allocate their private scratch on first use. + for tid in range(state.nworkers): + worker = &state.workers[tid] + worker.bindings = (state.workers + state.nworkers) + tid * state.ninputs + worker.decoders = ((state.workers + state.nworkers) + + state.nworkers * state.ninputs) + tid * state.ninputs + worker.fp_supported = 1 + for i in range(state.ninputs): + worker.bindings[i] = state.signature[i] + if self.array.sc.cctx != NULL: + blosc2_free_ctx(self.array.sc.cctx) + self.array.sc.cctx = blosc2_create_cctx(cparams[0]) + if self.array.sc.cctx == NULL: + raise MemoryError("Cannot create portable prefilter compression context") + try: + for chunk in range(begin, end): + # Fetch/validate each compressed input chunk once. The + # synchronous update joins all workers before these shared + # read-only pointers advance to the next chunk. + for i in range(state.ninputs): + if state.numpy_inputs[i] != NULL: + continue + if state.chunk_owned[i]: + free(state.chunks[i]) + state.chunks[i] = NULL + state.chunk_owned[i] = False + state.chunk_bytes[i] = blosc2_schunk_get_chunk(state.inputs[i].sc, chunk, + &state.chunks[i], &state.chunk_owned[i]) + input_chunk_fetches += 1 + if state.chunk_bytes[i] < 0: + state.status = -5 + state.error.native_status = state.chunk_bytes[i] + strcpy(state.error.message, "Portable prefilter could not read an input chunk") + raise_artifact_error(state.status, &state.error) + rc = blosc2_cbuffer_sizes(state.chunks[i], &decoded_bytes, &encoded_bytes, &block_bytes) + if rc < 0 or block_bytes != state.inputs[i].blockshape[0] * state.signature[i].itemsize: + state.status = -5 + state.error.native_status = rc + strcpy(state.error.message, "Portable prefilter input block layout mismatch") + raise_artifact_error(state.status, &state.error) + if numpy_out is not None: + # Always releases the GIL, including single-threaded + # contexts driven by independent coarse workers. + placeholder_bytes += self.schunk._prefilter_data(chunk, data, chunk_buffer) + else: + self.schunk.update_data(chunk, data, copy=False) + # In the uncompressed/disposable route callback failures + # are captured locally rather than propagated by Blosc2. + for tid in range(state.nworkers): + if state.workers[tid].status: + portable_prefilter_merge(&state) + raise_artifact_error(state.status, &state.error) + except Exception: + portable_prefilter_merge(&state) + if state.status: + raise_artifact_error(state.status, &state.error) + raise + portable_prefilter_merge(&state) + if state.status: + raise_artifact_error(state.status, &state.error) + finally: + if self.array.sc.cctx != NULL: + blosc2_free_ctx(self.array.sc.cctx) + cparams.prefilter = NULL + cparams.preparams = NULL + self.array.sc.cctx = blosc2_create_cctx(cparams[0]) + for tid in range(state.nworkers): + worker = &state.workers[tid] + free(worker.edge_output) + for i in range(state.ninputs): + if state.numpy_inputs[i] != NULL: + continue + if worker.decoders[i] != NULL: + decoder_contexts += 1 + blosc2_free_ctx(worker.decoders[i]) + if worker.bindings[i].data != NULL: + input_buffer_allocations += 1 + free(worker.bindings[i].data) + free(state.workers) + for i in range(state.ninputs): + if state.chunk_owned[i]: + free(state.chunks[i]) + result = numpy_out if numpy_out is not None else self + return result, {"route": "portable-prefilter", "evaluated_blocks": state.evaluated_blocks, + "output_destination": "numpy" if numpy_out is not None else "blosc2", + "discarded_output_bytes": placeholder_bytes, + "fp_flags": state.fp_flags, "fp_supported": bool(state.fp_supported), + "threads": cparams.nthreads, + "native_decoder_contexts": decoder_contexts, + "input_buffer_allocations": input_buffer_allocations, + "input_chunk_fetches": input_chunk_fetches, + "output_zero_fill_bytes": state.output_zero_fill_bytes, + "output_chunk_buffer_bytes": (chunk_buffer.nbytes if numpy_out is not None + else self.array.sc.chunksize), + "input_buffer_bytes": cparams.nthreads * sum( + state.block_items * source.dtype.itemsize for source in inputs.values() + if isinstance(source, NDArray))} + def _set_pref_udf(self, func, inputs_id): if self.array.sc.storage.cparams.nthreads > 1: raise AttributeError("compress `nthreads` must be 1 when assigning a prefilter") @@ -4979,3 +6786,53 @@ def get_loaded_matmul_cblas_library(): if path == NULL: return None return path.decode("utf-8") + + +def portable_artifact_options_available(): + return bool(b2_artifact_options_available()) + + +def portable_prefilter_inputs_eligible(inputs, allow_numpy=False, output=None): + """Metadata-only gate for bounded resident 1-D portable prefilters.""" + cdef NDArray value + if not b2_artifact_descriptor_available() or blosc2.IS_WASM or len(inputs) > 128: + return False + if not inputs and not isinstance(output, NDArray): + return False + first = next((source for source in inputs.values() if isinstance(source, NDArray)), None) + if first is None and (allow_numpy or not inputs): + first = output + if not isinstance(first, NDArray) or not first.size: + return False + if not inputs and first.ndim > 1: + return (first.ndim <= 16 and first.schunk.chunksize <= 32 * 1024**2) + if first.ndim != 1: + return False + if first.chunks[0] % first.blocks[0]: + return False + # The scheduling dummy chunk is host scratch, separate from input blocks. + # A supplied destination provides the exact output width; otherwise eight + # bytes covers every numeric output dtype admitted by the Python gate. + output_width = output.dtype.itemsize if isinstance(output, NDArray) else 8 + if first.chunks[0] * output_width > 32 * 1024**2: + return False + block_bytes = 0 + for source in inputs.values(): + if allow_numpy and type(source) is np.ndarray: + if (source.shape != first.shape or source.dtype.kind not in "biuf" or not source.dtype.isnative + or not source.flags.c_contiguous or not source.flags.aligned): + return False + continue + if not isinstance(source, NDArray): + return False + value = source + if source.shape != first.shape or source.chunks != first.chunks or source.blocks != first.blocks: + return False + if source.dtype.kind not in "biuf" or not source.dtype.isnative: + return False + if value.array.sc.storage.urlpath != NULL or value.array.sc.storage.dparams.postfilter != NULL: + return False + if source.schunk.cparams.use_dict: + return False + block_bytes += source.blocks[0] * source.dtype.itemsize + return block_bytes <= 32 * 1024**2 diff --git a/src/blosc2/core.py b/src/blosc2/core.py index b2ebfb75e..dfd9ed4cc 100644 --- a/src/blosc2/core.py +++ b/src/blosc2/core.py @@ -1286,11 +1286,9 @@ def set_nthreads(nthreads: int) -> int: Notes ----- The number of threads can also be set via the ``BLOSC_NTHREADS`` environment - variable (e.g., ``export BLOSC_NTHREADS=1``). Additionally, you may want to set - ``NUMEXPR_NUM_THREADS`` (e.g., ``export NUMEXPR_NUM_THREADS=1``) as well since - numexpr is used under the hood when performing some operations. Note that - this function only sets the number of threads used by Blosc, not the number - of threads used by numexpr. + variable (e.g., ``export BLOSC_NTHREADS=1``). Expression execution uses native + miniexpr scheduling or explicit NumPy fallbacks; NumExpr thread settings do + not affect Blosc2. The maximum number of threads for Blosc is :math:`2^{31} - 1`. In some cases, Blosc gets better results if you set the number of threads @@ -1511,9 +1509,7 @@ def print_versions(): print(f" {clib}: {clib_versions[clib]}") print(f"NumPy version: {np.__version__}") if not blosc2.IS_WASM: - import numexpr - - print(f"numexpr version: {numexpr.__version__}") + print("expression engines: miniexpr (interpreter/JIT), NumPy fallback") import httpx print(f"httpx version: {httpx.__version__}") @@ -2392,7 +2388,7 @@ def from_cframe( if "b2o" in schunk.meta: marker = schunk.meta["b2o"] kind = marker.get("kind", "b2o") if isinstance(marker, dict) else "b2o" - if deserialize is DeserializeMode.SAFE: + if deserialize is DeserializeMode.SAFE and kind not in {"portable", "lazyexpr"}: raise UnsafeDeserializationError(str(kind)) return blosc2.open_b2object(ndarray_from_cframe(cframe, copy=copy, deserialize=deserialize)) if "b2nd" in schunk.meta: diff --git a/src/blosc2/ctable.py b/src/blosc2/ctable.py index 491c3c2af..1cc54bce2 100644 --- a/src/blosc2/ctable.py +++ b/src/blosc2/ctable.py @@ -1337,7 +1337,10 @@ def __rxor__(self, other): def __invert__(self): na = self._null - return self._wrap(~self._true & ~na, na) + # These predicates may be backed by widened uint8 channels. Unary + # invert is then bitwise (1 -> 254), not logical negation; compare to + # zero so interpreter and JIT routes preserve boolean semantics. + return self._wrap((self._true == 0) & (na == 0), na) # ------------------------------------------------------------------ # Reading the third value @@ -2553,6 +2556,10 @@ def __invert__(self): # would otherwise say True for it: the mask one holds the ``False`` # fill, and the sentinel one holds 255, which is neither 0 nor 1. return ~kleene + if self.dtype == np.dtype(np.bool_): + # Some native routes widen boolean storage before evaluating + # unary invert, which would make this a bitwise operation. + return self._raw_col == 0 return ~self._raw_col def __lt__(self, other): @@ -2648,7 +2655,7 @@ def _utf8_compare(self, numpy_op, other): def _utf8_compare_column(self, numpy_op, other: Column): """Column-vs-Column comparison, evaluated chunk by chunk on decoded - ``StringDType`` values since numexpr/miniexpr cannot operate on them. + ``StringDType`` values since the expression engines do not operate on them. """ other_arr = other._raw_col nv = self.null_value @@ -3036,6 +3043,11 @@ def dtype(self): :func:`~blosc2.list`). :func:`~blosc2.utf8` columns report ``numpy.dtypes.StringDType()``, the dtype of their materialized reads. """ + recipe = self._table._computed_cols.get(self._col_name) + if recipe is not None and recipe.get("kind") == "portable": + # The native artifact fixes this dtype. Building the virtual column + # here would evaluate every row just to answer a metadata question. + return recipe["dtype"] return getattr(self._raw_col, "dtype", None) def iter_chunks(self, size: int = 65536): @@ -7007,6 +7019,7 @@ def to_b2z( """ if not str(urlpath).endswith(".b2z"): raise ValueError("urlpath must have a .b2z extension") + self._preflight_portable_persistence() if preserve_sources and self.base is not None: raise ValueError("preserve_sources requires an unfiltered root table") @@ -7075,6 +7088,7 @@ def to_b2d( """ urlpath = os.fspath(urlpath) storage = getattr(self, "_storage", None) + self._preflight_portable_persistence() can_physical_unpack = ( not compact and self.base is None @@ -7122,6 +7136,7 @@ def to_cframe(self, *, preserve_sources: bool = False) -> bytes: :func:`blosc2.ctable_from_cframe` """ # Materialize live rows for views/slices; for base tables use the live + self._preflight_portable_persistence() # columns directly. copy() is the canonical materialization path. if self.base is not None: src = self.copy(compact=True) @@ -7421,6 +7436,7 @@ def save(self, urlpath: str, *, overwrite: bool = False, preserve_sources: bool """ if preserve_sources and self.base is not None: raise ValueError("preserve_sources requires an unfiltered root table") + self._preflight_portable_persistence() if self.base is not None: materialized = self.copy(compact=True) materialized.save(urlpath, overwrite=overwrite) @@ -12166,6 +12182,8 @@ def _readable_computed_expr(cc: dict) -> str: ``kernel(dep0, dep1)`` call label is returned. """ col_deps = cc["col_deps"] + if cc.get("kind") == "portable": + return f"portable[independent]({', '.join(col_deps)})" if cc.get("kind") == "dsl": kernel = cc.get("kernel") kname = getattr(kernel, "__name__", "dsl_kernel") @@ -12260,7 +12278,19 @@ def _schema_dict_with_computed(self) -> dict: if self._computed_cols: computed = [] for name, cc in self._computed_cols.items(): - if cc.get("kind") == "dsl": + if cc.get("kind") == "portable": + computed.append( + { + "name": name, + "kind": "portable", + "artifact": cc["artifact"], + "bindings": cc["bindings"], + "row_shape": list(cc["row_shape"]), + "col_deps": cc["col_deps"], + "dtype": str(cc["dtype"]), + } + ) + elif cc.get("kind") == "dsl": entry = { "name": name, "kind": "dsl", @@ -12296,6 +12326,8 @@ def _schema_dict_with_computed(self) -> dict: } if "transformer" in meta: entry["transformer"] = meta["transformer"] + if meta.get("transformer_kind") == "portable": + entry.update({key: meta[key] for key in ("artifact", "bindings", "row_shape")}) if meta.get("dsl_source") is not None: entry["dsl_source"] = meta["dsl_source"] if meta.get("jit_backend") is not None: @@ -12490,11 +12522,14 @@ def _load_computed_cols_from_schema(self, schema_dict: dict) -> None: Called from ``__init__``, ``open``, and ``load`` after all stored columns have been opened into ``self._cols``. """ + self._check_legacy_dsl_policy(schema_dict) for cc_meta in schema_dict.get("computed_columns", []): name = cc_meta["name"] col_deps = cc_meta["col_deps"] dtype = np.dtype(cc_meta["dtype"]) - if cc_meta.get("kind") == "dsl": + if cc_meta.get("kind") == "portable": + self._computed_cols[name] = self._validate_portable_table_metadata(cc_meta) + elif cc_meta.get("kind") == "dsl": from blosc2.dsl_kernel import kernel_from_source dsl_source = cc_meta["dsl_source"] @@ -12508,8 +12543,13 @@ def _load_computed_cols_from_schema(self, schema_dict: dict) -> None: } else: expression = cc_meta["expression"] + from blosc2.expression_graph import select_evaluation + operands = {f"o{i}": self._cols[dep] for i, dep in enumerate(col_deps)} - lazy = blosc2.lazyexpr(expression, operands) + policy = self._expression_recipe_policy() + lazy = blosc2.lazyexpr( + expression, operands, evaluation=select_evaluation(expression, operands, policy) + ) self._computed_cols[name] = { "kind": "expression", "expression": expression, @@ -12522,8 +12562,10 @@ def _load_computed_cols_from_schema(self, schema_dict: dict) -> None: def _load_materialized_cols_from_schema(self, schema_dict: dict) -> None: """Reconstruct ``_materialized_cols`` from persisted metadata.""" + self._check_legacy_dsl_policy(schema_dict) for meta in schema_dict.get("materialized_columns", []): loaded = { + "_evaluation": self._expression_recipe_policy(), "computed_column": meta.get("computed_column"), "expression": meta.get("expression"), "col_deps": list(meta["col_deps"]), @@ -12533,12 +12575,77 @@ def _load_materialized_cols_from_schema(self, schema_dict: dict) -> None: } if "transformer" in meta: loaded["transformer"] = dict(meta["transformer"]) + if meta.get("transformer_kind") == "portable": + desc = self._validate_portable_table_metadata(meta) + if self._cols[meta["name"]].dtype != desc["dtype"]: + raise ValueError("Stored portable output dtype disagrees with native signature") + loaded.update({key: desc[key] for key in ("artifact", "bindings", "row_shape", "kernel")}) if meta.get("dsl_source") is not None: loaded["dsl_source"] = meta["dsl_source"] if meta.get("jit_backend") is not None: loaded["jit_backend"] = meta["jit_backend"] self._materialized_cols[meta["name"]] = loaded + def _expression_recipe_policy(self): + """Effective loading permission, never a policy supplied by recipe text.""" + storage = self._storage + return str( + getattr( + storage, + "_deserialize_mode", + getattr(getattr(storage, "_store", None), "_deserialize_mode", "safe"), + ) + ) + + def _check_legacy_dsl_policy(self, schema_dict): + from blosc2.deserialization import DeserializeMode, normalize_deserialize + from blosc2.exceptions import UnsafeDeserializationError + from blosc2.expression_graph import parse_expression + + if normalize_deserialize(self._expression_recipe_policy()) is DeserializeMode.SAFE: + recipes = [ + *schema_dict.get("computed_columns", []), + *schema_dict.get("materialized_columns", []), + ] + for recipe in recipes: + if recipe.get("expression") is not None: + parse_expression(recipe["expression"]) + + legacy = any( + cc.get("kind") == "dsl" or "dsl_source" in cc for cc in schema_dict.get("computed_columns", []) + ) or any( + meta.get("dsl_source") is not None or meta.get("transformer_kind") == "dsl" + for meta in schema_dict.get("materialized_columns", []) + ) + storage = self._storage + policy = getattr( + storage, + "_deserialize_mode", + getattr(getattr(storage, "_store", None), "_deserialize_mode", "safe"), + ) + if legacy and normalize_deserialize(policy) is not DeserializeMode.FULL: + raise UnsafeDeserializationError( + "legacy DSL table columns with block/batch-dependent evaluation", + location="CTable column recipes", + hint="Reopen with deserialize='full' only if you trust this data and " + "intend to retain legacy table-kernel behavior.", + ) + + def _preflight_portable_persistence(self): + for meta in [*self._computed_cols.values(), *self._materialized_cols.values()]: + if meta.get("kind") == "portable" or meta.get("transformer_kind") == "portable": + self._validate_portable_table_metadata(meta) + if any(cc.get("kind") == "dsl" for cc in self._computed_cols.values()) or any( + meta.get("dsl_source") is not None or meta.get("transformer_kind") == "dsl" + for meta in self._materialized_cols.values() + ): + raise TypeError( + "Source-authored vector table columns have no explicit row-domain contract; " + "use add_computed_column or add_generated_column with " + "the DSLKernel, named inputs, and dtype=.... " + "Legacy source metadata is not automatically migrated." + ) + def _require_computed_column(self, name: str) -> dict: """Return metadata for computed column *name* or raise ``KeyError``.""" try: @@ -12562,12 +12669,17 @@ def _autofill_materialized_row_values(self, row: dict[str, Any]) -> dict[str, An if meta.get("transformer_kind") == "row_transformer": transformer = RowTransformer.from_metadata(meta["transformer"]) row[name] = np.asarray(transformer.evaluate_row(row), dtype=meta["dtype"]) + elif meta.get("transformer_kind") == "portable": + single = {dep: [row[dep]] for dep in meta["col_deps"]} + row[name] = self._evaluate_portable_rows(meta, single, count=1)[0] elif meta.get("transformer_kind") == "dsl": single = {dep: [row[dep]] for dep in meta["col_deps"]} row[name] = self._evaluate_dsl_materialized_batch(meta, single)[0] else: operands = {f"o{i}": np.asarray([row[dep]]) for i, dep in enumerate(meta["col_deps"])} - values = blosc2.lazyexpr(meta["expression"], operands)[:] + values = blosc2.lazyexpr( + meta["expression"], operands, evaluation=meta.get("_evaluation", "full") + )[:] row[name] = np.asarray(values, dtype=meta["dtype"])[0] return row @@ -12609,6 +12721,8 @@ def _autofill_materialized_batch_columns( if meta.get("transformer_kind") == "row_transformer": transformer = RowTransformer.from_metadata(meta["transformer"]) values = transformer.evaluate_batch(raw_columns) + elif meta.get("transformer_kind") == "portable": + values = self._evaluate_portable_rows(meta, raw_columns) elif meta.get("transformer_kind") == "dsl": values = self._evaluate_dsl_materialized_batch(meta, raw_columns) else: @@ -12616,7 +12730,9 @@ def _autofill_materialized_batch_columns( f"o{i}": blosc2.asarray(raw_columns[dep], dtype=self._cols[dep].dtype) for i, dep in enumerate(meta["col_deps"]) } - values = blosc2.lazyexpr(meta["expression"], operands)[:] + values = blosc2.lazyexpr( + meta["expression"], operands, evaluation=meta.get("_evaluation", "full") + )[:] values = np.asarray(values, dtype=meta["dtype"]) if len(values) != row_count: raise ValueError( @@ -12787,9 +12903,18 @@ def materialize_computed_column( if target_name in self._computed_cols: raise ValueError(f"A computed column named {target_name!r} already exists.") target_dtype = np.dtype(dtype) if dtype is not None else np.dtype(cc["dtype"]) + if cc.get("kind") == "portable" and target_dtype != cc["dtype"]: + raise ValueError("Portable materialization cannot override its native result dtype") self._create_empty_stored_column(target_name, target_dtype, cparams=cparams) - if cc.get("kind") == "dsl": + if cc.get("kind") == "portable": + self._materialized_cols[target_name] = { + **cc, + "computed_column": name, + "transformer_kind": "portable", + "stale": False, + } + elif cc.get("kind") == "dsl": self._materialized_cols[target_name] = { "computed_column": name, "expression": None, @@ -12884,26 +13009,6 @@ def _dsl_deps_from_lazyudf(self, lazyudf) -> list[str]: col_deps.append(cname) return col_deps - def _resolve_dsl_kernel(self, kernel, inputs) -> tuple[Any, list[str]]: - """Validate a bare DSL kernel + its ``inputs`` column bindings.""" - if kernel.dsl_error is not None: - raise blosc2.DSLSyntaxError(f"Invalid DSL kernel: {kernel.dsl_error}") - if inputs is None: - raise TypeError( - "A DSL kernel passed directly requires inputs=[...] naming one source " - "column per kernel parameter." - ) - col_deps = list(inputs) - expected = kernel.input_names - if expected is not None and len(col_deps) != len(expected): - raise ValueError( - f"DSL kernel expects {len(expected)} input(s) {expected}, " - f"but inputs={col_deps} provides {len(col_deps)}." - ) - for d in col_deps: - self._validate_transformer_dep(d) - return kernel, col_deps - def _guard_utf8_kernel_deps(self, col_deps) -> None: """Refuse a UDF/DSL kernel that reads a utf8 column, naming the column. @@ -12929,23 +13034,36 @@ def _guard_utf8_kernel_deps(self, col_deps) -> None: ) ) - def _normalize_transformer(self, expr, inputs=None) -> dict: + def _normalize_transformer(self, expr, inputs=None, *, dtype=None, cardinality="elementwise") -> dict: """Resolve *expr* into a transformer descriptor. Returns one of:: {"kind": "expression", "lazy": , "col_deps": [...]} - {"kind": "dsl", "kernel": , "col_deps": [...]} + {"kind": "portable", "kernel": , "bindings": {...}, ...} A ``@blosc2.dsl_kernel`` is accepted either directly (with *inputs* naming one source column per kernel parameter) or as a ``LazyUDF`` returned by a callable (then operands are matched to columns by identity and *inputs* is ignored). + New kernel registrations always validate/export Menudet and evaluate + independent rows; only loaded legacy recipes use vector-column execution. """ - if isinstance(expr, blosc2.DSLKernel): - kernel, col_deps = self._resolve_dsl_kernel(expr, inputs) - self._guard_utf8_kernel_deps(col_deps) - return {"kind": "dsl", "kernel": kernel, "col_deps": col_deps} + if isinstance(expr, blosc2.DSLKernel | blosc2.PortableKernel): + names = expr.input_names if isinstance(expr, blosc2.DSLKernel) else list(expr.input_dtypes) + if inputs is None: + raise TypeError("A table kernel requires inputs= naming one source column per parameter") + if isinstance(inputs, Mapping): + bindings = dict(inputs) + else: + if len(inputs) != len(names): + raise ValueError(f"Kernel expects {len(names)} inputs, but received {len(inputs)}") + bindings = dict(zip(names, inputs, strict=True)) + self._guard_utf8_kernel_deps(bindings.values()) + if isinstance(expr, blosc2.DSLKernel): + output_dtype = dtype if isinstance(dtype, type) else getattr(dtype, "dtype", dtype) + dtype = self._dsl_result_dtype(expr, list(bindings.values()), output_dtype) + return self._portable_table_descriptor(expr, bindings, dtype=dtype, cardinality=cardinality) # Resolve a callable once (a lambda may return a LazyExpr or a LazyUDF). obj = expr(self._cols) if (callable(expr) and not isinstance(expr, blosc2.LazyExpr)) else expr if isinstance(obj, blosc2.LazyUDF): @@ -12958,12 +13076,12 @@ def _normalize_transformer(self, expr, inputs=None) -> dict: raise blosc2.DSLSyntaxError(f"Invalid DSL kernel: {kernel.dsl_error}") col_deps = self._dsl_deps_from_lazyudf(obj) self._guard_utf8_kernel_deps(col_deps) - return { - "kind": "dsl", - "kernel": kernel, - "col_deps": col_deps, - "jit_backend": obj.kwargs.get("jit_backend"), - } + return self._normalize_transformer( + kernel, + dict(zip(kernel.input_names, col_deps, strict=True)), + dtype=obj.dtype if dtype is None else dtype, + cardinality=cardinality, + ) lazy, col_deps = self._normalize_expression_transformer(obj) # Guard: verify the expression string round-trips before storing. # An empty string means the LazyExpr was not fully constructed, and a @@ -13018,8 +13136,16 @@ def _build_computed_lazy(self, cc: dict): (the all-NDArray miniexpr fast path). The full column is recomputed on each access — acceptable for a virtual, unstored column. """ + if cc.get("kind") == "portable": + positions = np.flatnonzero(self._valid_rows[:]) + raw = {dep: self._cols[dep][positions] for dep in cc["col_deps"]} + values = self._evaluate_portable_rows(cc, raw, count=len(positions)) + output = np.zeros(len(self._valid_rows), dtype=cc["dtype"]) + output[positions] = values + return blosc2.asarray(output) if cc.get("kind") == "dsl": operands = tuple(self._cols[d] for d in cc["col_deps"]) + cc["kernel"]._legacy_source_recipe = True return blosc2.lazyudf( cc["kernel"], operands, @@ -13035,7 +13161,7 @@ def _evaluate_expression_materialized_batch( f"o{i}": blosc2.asarray(raw_columns[dep], dtype=self._cols[dep].dtype) for i, dep in enumerate(meta["col_deps"]) } - values = blosc2.lazyexpr(meta["expression"], operands)[:] + values = blosc2.lazyexpr(meta["expression"], operands, evaluation=meta.get("_evaluation", "full"))[:] return np.asarray(values, dtype=meta["dtype"]) def _materialized_dsl_kernel(self, meta: dict): @@ -13045,6 +13171,7 @@ def _materialized_dsl_kernel(self, meta: dict): from blosc2.dsl_kernel import kernel_from_source kernel = kernel_from_source(meta["dsl_source"]) + kernel._legacy_source_recipe = True meta["_kernel"] = kernel # not serialized (schema dump emits known keys only) return kernel @@ -13084,6 +13211,103 @@ def _generated_dependency_closure(self, source: str) -> set[str]: queue.append(name) return affected + def _portable_table_descriptor(self, kernel, bindings, *, dtype=None, cardinality="elementwise"): + if isinstance(kernel, blosc2.DSLKernel): + if dtype is None: + raise ValueError("Authored portable table kernels require an explicit output dtype") + bindings = dict(bindings) + if any(dep not in self._cols for dep in bindings.values()): + raise ValueError("Portable row inputs require stored columns") + row_shape = ( + np.broadcast_shapes(*(tuple(self._cols[dep].shape[1:]) or (1,) for dep in bindings.values())) + if bindings + else (1,) + ) + kernel = blosc2.PortableKernel.from_json( + kernel.export( + {name: self._cols[dep].dtype for name, dep in bindings.items()}, + dtype, + version="1.0", + ndim=len(row_shape), + cardinality=cardinality, + ), + jit=False, + ) + if not isinstance(kernel, blosc2.PortableKernel): + raise TypeError("Portable table transformers require a validated PortableKernel") + output_dtype = dtype if isinstance(dtype, type) else getattr(dtype, "dtype", dtype) + if dtype is not None and np.dtype(output_dtype) != kernel.output_dtype: + raise ValueError("Output dtype disagrees with the portable kernel signature") + if kernel.schema_version != "1.0": + raise ValueError("Independent rows require portable 1.0") + bindings = dict(bindings) + if set(bindings) != set(kernel.input_dtypes): + raise ValueError("Portable table bindings must match the native signature") + row_shapes = set() + for name, dep in bindings.items(): + if dep not in self._cols: + raise ValueError("Portable row inputs require stored columns") + row_shapes.add(tuple(self._cols[dep].shape[1:]) or (1,)) + if np.dtype(self._cols[dep].dtype) != kernel.input_dtypes[name]: + raise ValueError("Portable table column dtype disagrees with the native signature") + row_shape = np.broadcast_shapes(*row_shapes) if row_shapes else (1,) + if kernel.context_ndim not in (0, len(row_shape)): + raise ValueError("Portable context rank disagrees with the fixed row domain") + if row_shape != (1,) and kernel.result_cardinality != "block_scalar": + raise ValueError("Fixed-shape row transformers currently require scalar native returns") + return { + "kind": "portable", + "kernel": kernel, + "artifact": kernel.to_json(), + "bindings": bindings, + "row_shape": row_shape, + "col_deps": list(dict.fromkeys(bindings.values())), + "dtype": kernel.output_dtype, + } + + def _validate_portable_table_metadata(self, meta): + kernel = blosc2.PortableKernel.from_json(meta["artifact"]) + if meta.get("row_domain", "independent") != "independent": + raise ValueError("Only independent-row portable table groups are implemented") + desc = self._portable_table_descriptor(kernel, meta["bindings"]) + if ( + desc["dtype"] != np.dtype(meta["dtype"]) + or desc["col_deps"] != meta["col_deps"] + or desc["row_shape"] != tuple(meta.get("row_shape", (1,))) + ): + raise ValueError("Portable table metadata disagrees with native signature/bindings") + return desc + + def _evaluate_portable_rows(self, meta, raw_columns, *, count=None): + kernel = meta.get("kernel") + if kernel is None: + kernel = blosc2.PortableKernel.from_json(meta["artifact"]) + arrays = { + name: np.asarray(raw_columns[dep], dtype=kernel.input_dtypes[name]) + for name, dep in meta["bindings"].items() + } + if count is None: + count = len(next(iter(raw_columns.values()))) + if any(len(array) != count for array in arrays.values()): + raise ValueError("Portable row operands disagree on batch length") + result = np.empty(count, dtype=kernel.output_dtype) + row_shape = tuple(meta["row_shape"]) + context = ( + {"logical_shape": row_shape, "block_origin": (0,) * len(row_shape)} + if kernel.context_ndim + else {} + ) + for row in range(count): + # Slice, rather than extract a scalar: NumPy scalar strings discard + # the declared slot width and would invalidate the native signature. + inputs = { + name: np.broadcast_to(array[row : row + 1].reshape(array.shape[1:] or (1,)), row_shape) + for name, array in arrays.items() + } + value = kernel.evaluate_block(inputs, block_shape=row_shape, **context) + result[row] = value[()] if value.shape == () else value[0] + return result + def _mark_generated_columns_stale(self, source: str) -> None: affected = self._generated_dependency_closure(source) changed = False @@ -13106,6 +13330,9 @@ def refresh_generated_column(self, name: str) -> None: if meta.get("transformer_kind") == "row_transformer": transformer = RowTransformer.from_metadata(meta["transformer"]) values = np.asarray(transformer.evaluate_existing(self), dtype=meta["dtype"]) + elif meta.get("transformer_kind") == "portable": + raw_columns = {dep: self[dep][:] for dep in meta["col_deps"]} + values = self._evaluate_portable_rows(meta, raw_columns, count=len(self)) elif meta.get("transformer_kind") == "dsl": raw_columns = {dep: self[dep][:] for dep in meta["col_deps"]} values = self._evaluate_dsl_materialized_batch(meta, raw_columns) @@ -13214,11 +13441,13 @@ def add_generated_column( # noqa: C901 values: str | blosc2.LazyExpr | blosc2.DSLKernel + | blosc2.PortableKernel | Callable[[dict[str, Any]], blosc2.LazyExpr] | RowTransformer, dtype=None, create_index: bool = False, - inputs: list[str] | None = None, + inputs: Mapping[str, str] | list[str] | None = None, + cardinality: str = "elementwise", ) -> None: """Add a stored generated column maintained by the table. @@ -13234,7 +13463,8 @@ def add_generated_column( # noqa: C901 add_generated_column(name, *, values="price * qty", dtype=..., create_index=False) add_generated_column(name, *, values=lazy_expr, dtype=...) - add_generated_column(name, *, values=dsl_kernel, inputs=["price", "qty"], dtype=...) + add_generated_column(name, *, values=dsl_kernel, + inputs={"price": "price", "qty": "qty"}, dtype=...) add_generated_column(name, *, values=blosc2.lazyudf(dsl_kernel, (t.price, t.qty))) add_generated_column(name, *, values=lambda cols: cols["price"] * 1.21, dtype=...) add_generated_column(name, *, values=t.embedding.row_transformer.norm(axis=0), dtype=...) @@ -13255,17 +13485,18 @@ def add_generated_column( # noqa: C901 per row. * :class:`blosc2.LazyExpr`: scalar lazy expression over stored columns of this table. It must produce a 1-D scalar stream. - * :func:`blosc2.dsl_kernel`-decorated kernel passed directly with - ``inputs=[...]`` — one stored scalar column name per kernel - parameter, bound positionally. Produces one scalar per row. - The kernel source is persisted and recompiled on open; appended - rows are auto-filled and :meth:`refresh_generated_column` - recomputes after in-place edits. + * :class:`blosc2.DSLKernel` or :class:`blosc2.PortableKernel` with + named ``inputs={parameter: column}`` bindings (positional lists + are also accepted). Menudet artifacts are validated before + registration and persisted without Python reconstruction. + Each row is an independent logical group, including its complete + fixed-shape array inputs. Appended rows are auto-filled and + :meth:`refresh_generated_column` recomputes after in-place edits. * :class:`blosc2.LazyUDF` built from a :func:`blosc2.dsl_kernel` via :func:`blosc2.lazyudf` — column bindings are inferred by identity from the operands, so ``inputs=`` is not needed. Accepts :class:`Column` accessors (``t.col1``) or raw NDArrays as - operands. Same persistence and auto-fill behaviour as above. + operands. Same independent-row semantics and persistence as above. * callable: called as ``values(self._cols)`` and must return a :class:`blosc2.LazyExpr` or a :class:`blosc2.LazyUDF` backed by a :func:`blosc2.dsl_kernel`. @@ -13276,9 +13507,10 @@ def add_generated_column( # noqa: C901 may produce either one scalar per row or one fixed-shape ndarray item per row. - Expression and DSL forms currently cannot depend on computed columns - and cannot directly consume fixed-shape ndarray columns; use a - row-transformer for ndarray row projections/reductions. + These forms cannot depend on computed columns. Expressions cannot + consume fixed-shape ndarray columns; kernels support scalar row + reductions with ``cardinality="block_scalar"``. Row transformers + also support fixed-shape vector outputs. dtype: Output schema or dtype. Scalar outputs may pass a NumPy dtype or a Blosc2 scalar spec such as ``blosc2.float64()``. Fixed-shape @@ -13293,10 +13525,13 @@ def add_generated_column( # noqa: C901 generated columns raise :class:`ValueError` when indexing is requested. inputs: - Only used when *values* is a bare :func:`blosc2.dsl_kernel`: a list - of stored scalar column names, one per kernel parameter, bound - positionally. Not needed when passing a :class:`blosc2.LazyUDF` or - a callable — bindings are inferred from the operands in those cases. + For bare kernels, a mapping from parameter names to stored columns, + or a positional list of column names. LazyUDF bindings are inferred + from their operands. + cardinality: + Result contract for authored kernels: ``"elementwise"`` by default; + use ``"block_scalar"`` for fixed-shape row reductions. A + :class:`blosc2.PortableKernel` already carries its result contract. Examples -------- @@ -13403,36 +13638,19 @@ def add_generated_column( # noqa: C901 "transformer": transformer.to_metadata(), "stale": False, } - elif (desc := self._normalize_transformer(values, inputs))["kind"] == "dsl": - kernel = desc["kernel"] - col_deps = desc["col_deps"] - compute_dtype = ( - np.dtype(getattr(dtype, "dtype", dtype)) - if dtype is not None - else self._dsl_result_dtype(kernel, col_deps, None) - ) - jit_backend = desc.get("jit_backend") - operands = tuple(self._cols[d] for d in col_deps) - generated_values = np.asarray( - blosc2.lazyudf(kernel, operands, dtype=compute_dtype, jit_backend=jit_backend).compute()[:] - ) - if generated_values.ndim != 1: - raise TypeError("DSL generated columns must produce a 1-D scalar result.") - generated_values = ( - generated_values[self._valid_rows[:]] - if len(generated_values) == len(self._valid_rows) - else generated_values - ) + elif (desc := self._normalize_transformer(values, inputs, dtype=dtype, cardinality=cardinality))[ + "kind" + ] == "portable": + raw = {dep: self[dep][:] for dep in desc["col_deps"]} + generated_values = self._evaluate_portable_rows(desc, raw, count=n_live) spec = self._coerce_generated_spec(dtype, generated_values) metadata = { + **desc, "computed_column": None, "expression": None, - "dsl_source": kernel.dsl_source, - "col_deps": col_deps, "dtype": np.dtype(spec.dtype), - "transformer_kind": "dsl", + "transformer_kind": "portable", "stale": False, - "jit_backend": jit_backend, } else: lazy, col_deps = desc["lazy"], desc["col_deps"] @@ -13482,10 +13700,15 @@ def add_generated_column( # noqa: C901 def add_computed_column( self, name: str, - expr: str | blosc2.LazyExpr | blosc2.DSLKernel | Callable[[dict[str, Any]], blosc2.LazyExpr], + expr: str + | blosc2.LazyExpr + | blosc2.DSLKernel + | blosc2.PortableKernel + | Callable[[dict[str, Any]], blosc2.LazyExpr], *, dtype: np.dtype | None = None, - inputs: list[str] | None = None, + inputs: Mapping[str, str] | list[str] | None = None, + cardinality: str = "elementwise", ) -> None: """Add a read-only virtual column computed from stored columns. @@ -13501,7 +13724,7 @@ def add_computed_column( add_computed_column(name, "price * qty") add_computed_column(name, lazy_expr) - add_computed_column(name, dsl_kernel, inputs=["price", "qty"]) + add_computed_column(name, dsl_kernel, inputs={"price": "price", "qty": "qty"}) add_computed_column(name, blosc2.lazyudf(dsl_kernel, (t.price, t.qty))) add_computed_column(name, lambda cols: cols["price"] * cols["qty"]) @@ -13517,11 +13740,10 @@ def add_computed_column( ``"price * qty"``. * :class:`blosc2.LazyExpr`: lazy expression over stored columns of this table. - * :func:`blosc2.dsl_kernel`-decorated kernel passed directly with - ``inputs=[...]`` — one stored scalar column name per kernel - parameter, bound positionally. The kernel may use loops, - ``if``/``else`` and ``where(...)``. Its source is persisted and - recompiled on open; the column stays virtual/unstored. + * :class:`blosc2.DSLKernel` or :class:`blosc2.PortableKernel` with + named ``inputs={parameter: column}`` bindings (positional lists + are also accepted). Kernels are validated as Menudet before + registration and persist without Python reconstruction. * :class:`blosc2.LazyUDF` built from a :func:`blosc2.dsl_kernel` via :func:`blosc2.lazyudf` — column bindings are inferred by identity from the operands, so ``inputs=`` is not needed. Accepted forms @@ -13531,16 +13753,19 @@ def add_computed_column( :class:`blosc2.LazyExpr` or a :class:`blosc2.LazyUDF` backed by a :func:`blosc2.dsl_kernel`. - DSL columns (last three forms) are persisted — their source is stored - and recompiled on open — and may be referenced inside :meth:`where` - predicates. + Kernel columns use independent-row semantics: scalar inputs form + one-lane groups and fixed-shape inputs supply their complete row. + Reductions never combine different rows. The column remains virtual + and may be referenced inside :meth:`where` predicates. Loaded legacy + table recipes require ``deserialize="full"`` and retain their old + block/batch-dependent semantics, rather than being reinterpreted. Expressions must depend only on stored columns of this table; computed columns cannot depend on other computed columns in this version. Fixed-shape ndarray columns are not accepted in computed - column expressions yet. For row-wise ndarray projections or - reductions, use :meth:`add_generated_column` with - ``values=t.ndarray_col.row_transformer...``. + column expressions yet. Kernels can reduce complete ndarray rows + with ``cardinality="block_scalar"``; generated row transformers + additionally support vector-valued outputs. dtype: Optional dtype override for the computed values. For expression forms it is inferred from the resulting :class:`blosc2.LazyExpr` @@ -13551,11 +13776,13 @@ def add_computed_column( column inputs. This changes the dtype reported by the CTable column wrapper; it does not create physical storage. inputs: - Only used when *expr* is a bare :func:`blosc2.dsl_kernel`: a list of - stored scalar column names, one per kernel parameter, bound - positionally (kernel parameter ``i`` ← ``inputs[i]``). Not needed - when passing a :class:`blosc2.LazyUDF` or a callable — bindings are - inferred from the operands in those cases. + For bare kernels, a mapping from parameter names to stored columns, + or a positional list of column names. LazyUDF bindings are inferred + from their operands. + cardinality: + Result contract for authored kernels: ``"elementwise"`` by default; + use ``"block_scalar"`` for fixed-shape row reductions. A + :class:`blosc2.PortableKernel` already carries its result contract. Examples -------- @@ -13633,18 +13860,9 @@ def ratio(num, den): if name in self._computed_cols: raise ValueError(f"A computed column named {name!r} already exists.") - desc = self._normalize_transformer(expr, inputs) - if desc["kind"] == "dsl": - kernel = desc["kernel"] - col_deps = desc["col_deps"] - self._computed_cols[name] = { - "kind": "dsl", - "dsl_source": kernel.dsl_source, - "kernel": kernel, - "col_deps": col_deps, - "dtype": self._dsl_result_dtype(kernel, col_deps, dtype), - "jit_backend": desc.get("jit_backend"), - } + desc = self._normalize_transformer(expr, inputs, dtype=dtype, cardinality=cardinality) + if desc["kind"] == "portable": + self._computed_cols[name] = desc else: lazy = desc["lazy"] self._computed_cols[name] = { @@ -13779,17 +13997,8 @@ def assign(self, **named_exprs) -> CTable: view._col_widths = dict(self._col_widths) for name, value in bound.items(): desc = view._normalize_transformer(value) - if desc["kind"] == "dsl": - kernel = desc["kernel"] - col_deps = desc["col_deps"] - view._computed_cols[name] = { - "kind": "dsl", - "dsl_source": kernel.dsl_source, - "kernel": kernel, - "col_deps": col_deps, - "dtype": view._dsl_result_dtype(kernel, col_deps, None), - "jit_backend": desc.get("jit_backend"), - } + if desc["kind"] == "portable": + view._computed_cols[name] = desc else: lazy = desc["lazy"] view._computed_cols[name] = { @@ -14895,6 +15104,7 @@ def copy( # noqa: C901 the source. """ if urlpath is not None: + self._preflight_portable_persistence() urlpath = os.fspath(urlpath) if chunks is not None or blocks is not None or cparams is not None: # When storage layout changes we must go through _save_to_storage @@ -15138,21 +15348,13 @@ def _empty_copy( # Rebuild computed columns with the new NDArray objects as operands obj._computed_cols = {} for cc_name, cc in self._computed_cols.items(): - if cc.get("kind") == "dsl": - # DSL entries hold the live kernel; the LazyUDF is rebuilt on - # demand from obj._cols, so no operand rebinding is needed here. - dsl_entry: dict[str, Any] = { - "kind": "dsl", - "dsl_source": cc["dsl_source"], - "kernel": cc["kernel"], - "col_deps": cc["col_deps"], - "dtype": cc["dtype"], - **({"jit_backend": cc["jit_backend"]} if "jit_backend" in cc else {}), - } - obj._computed_cols[cc_name] = dsl_entry + if cc.get("kind") in {"portable", "dsl"}: + # Native/source descriptors resolve columns on demand. Neither + # retains the old table's array operands in a cached expression. + obj._computed_cols[cc_name] = dict(cc) else: operands = {f"o{i}": new_cols[dep] for i, dep in enumerate(cc["col_deps"])} - new_lazy = blosc2.lazyexpr(cc["expression"], operands) + new_lazy = blosc2.lazyexpr(cc["expression"], operands, evaluation=cc["lazy"]._evaluation) obj._computed_cols[cc_name] = { "kind": "expression", "expression": cc["expression"], @@ -15946,9 +16148,9 @@ def in_repl(match: re.Match, _dc=dc, _name=name) -> str: new_expr = re.sub(eq_pattern, eq_repl, rewritten) new_expr = re.sub(in_pattern, in_repl, new_expr) if new_expr != rewritten: - # numexpr needs all operands chunked alike; the codes array uses a - # different chunkshape than the regular columns, so when mixed with - # one (e.g. ``dictcol == "x" and other > y``) re-chunk it to match. + # Expression evaluation needs all operands chunked alike; the codes + # array uses a different chunkshape than the regular columns, so when + # mixed with one (e.g. ``dictcol == "x" and other > y``) re-chunk it. codes = dc.codes target = next( ( diff --git a/src/blosc2/ctable_nulls.py b/src/blosc2/ctable_nulls.py index 0bcedbb77..ea2cfa4bf 100644 --- a/src/blosc2/ctable_nulls.py +++ b/src/blosc2/ctable_nulls.py @@ -958,7 +958,9 @@ def null_pred(self): return None if _is_nan(sentinel): return blosc2.isnan(col._raw_col) - return col._raw_col == sentinel + # This internal predicate must remain lazy even while expression fusion + # temporarily disables user-facing overloaded equality for identity checks. + return blosc2.LazyExpr(new_op=(col._raw_col, "==", sentinel)) def valid_pred(self): """Lazy predicate over the raw physical array, True where the value is *not* null. diff --git a/src/blosc2/ctable_storage.py b/src/blosc2/ctable_storage.py index c58900bfd..4e61e9e8a 100644 --- a/src/blosc2/ctable_storage.py +++ b/src/blosc2/ctable_storage.py @@ -663,6 +663,7 @@ def __init__(self, records, name, dtype=None): self.records = records self.field = name self._storage_dtype = np.dtype(records.dtype.fields[name][0]) + self._logical_dtype_override = dtype is not None self._dtype = self._storage_dtype if dtype is None else np.dtype(dtype) self._shape = records.shape self.chunks = records.chunks diff --git a/src/blosc2/deserialization.py b/src/blosc2/deserialization.py index 627163c4e..c71cc4f89 100644 --- a/src/blosc2/deserialization.py +++ b/src/blosc2/deserialization.py @@ -37,6 +37,8 @@ def get_deserialize(obj: Any, default: str | DeserializeMode = DeserializeMode.F """Return the policy attached to *obj* or its physical SChunk carrier.""" carrier = getattr(obj, "schunk", obj) + if carrier is None: + carrier = obj return normalize_deserialize(getattr(carrier, "_deserialize_mode", default)) @@ -45,6 +47,8 @@ def set_deserialize(obj: Any, value: str | DeserializeMode) -> Any: mode = normalize_deserialize(value) carrier = getattr(obj, "schunk", obj) + if carrier is None: + carrier = obj current = getattr(carrier, "_deserialize_mode", None) if current is not None and normalize_deserialize(current) is not mode: raise ValueError( diff --git a/src/blosc2/dict_store.py b/src/blosc2/dict_store.py index b173b6b3b..4d337aa3b 100644 --- a/src/blosc2/dict_store.py +++ b/src/blosc2/dict_store.py @@ -8,6 +8,7 @@ from __future__ import annotations import contextlib +import math import os import shutil import tempfile @@ -603,6 +604,10 @@ def _sync_store(self) -> None: def _value_nbytes(value: blosc2.Array | SChunk | blosc2.ObjectArray | blosc2.BatchArray) -> int: if isinstance(value, blosc2.ObjectArray | blosc2.BatchArray): return value.schunk.nbytes + if isinstance(value, blosc2.LazyArray): + # Choose a storage tier from logical metadata, without evaluating + # a deferred expression merely to estimate its result size. + return math.prod(value.shape) * np.dtype(value.dtype).itemsize return value.nbytes @staticmethod @@ -625,6 +630,9 @@ def __setitem__( self, key: str, value: blosc2.Array | SChunk | blosc2.ObjectArray | blosc2.BatchArray ) -> None: """Add a node to the DictStore.""" + from blosc2.b2objects import preflight_persistence + + preflight_persistence(value) self._modified = True if isinstance(value, np.ndarray): value = blosc2.asarray(value, cparams=self.cparams, dparams=self.dparams) diff --git a/src/blosc2/dsl_array_bridge.h b/src/blosc2/dsl_array_bridge.h new file mode 100644 index 000000000..d617e4105 --- /dev/null +++ b/src/blosc2/dsl_array_bridge.h @@ -0,0 +1,64 @@ +#ifndef BLOSC2_DSL_ARRAY_BRIDGE_H +#define BLOSC2_DSL_ARRAY_BRIDGE_H +#include "dsl_artifact_bridge.h" +#ifdef ME_ARTIFACT_ARRAY_VERSION +typedef me_array_view b2_array_view; +typedef me_array_options b2_array_options; +typedef me_array_report b2_array_report; +static int b2_array_shape(const void *handle, int rank, const int64_t *shape, + const b2_array_options *options, int *out_rank, int64_t *out_shape, + me_dtype *dtype, b2_artifact_error *error) { + return me_array_result_shape(handle,rank,shape,options,out_rank,out_shape,dtype,error); +} +static int b2_array_eval(const void *handle, const b2_array_view *inputs, int ninputs, + int rank, const int64_t *shape, const b2_array_options *options, void *output, + size_t capacity, b2_array_report *report, b2_artifact_error *error) { + return me_artifact_eval_array(handle,inputs,ninputs,rank,shape,options,output,capacity,report,error); +} +#else +typedef struct { + const char *name; me_dtype dtype; const void *base; + size_t capacity; size_t offset; int rank; + int64_t shape[16]; int64_t strides[16]; unsigned byte_order; +} b2_array_view; +typedef struct { + unsigned version; int reduction; int naxes; int axes[16]; bool keepdims; + me_dtype accumulator; const void *initial; size_t tile_items; const b2_array_view *where; +} b2_array_options; +typedef struct { + size_t temporary_bytes; size_t gathered_bytes; size_t zero_copy_tiles; + size_t evaluated_tiles; unsigned fp_flags; unsigned fp_supported; +} b2_array_report; +static int b2_array_shape(const void *handle, int rank, const int64_t *shape, + const b2_array_options *options, int *out_rank, int64_t *out_shape, + me_dtype *dtype, b2_artifact_error *error) { + (void)handle; (void)rank; (void)shape; (void)options; (void)out_rank; (void)out_shape; (void)dtype; + memset(error,0,sizeof(*error)); snprintf(error->message,sizeof(error->message),"Native runtime does not support logical arrays"); return -2; +} +static int b2_array_eval(const void *handle, const b2_array_view *inputs, int ninputs, + int rank, const int64_t *shape, const b2_array_options *options, void *output, + size_t capacity, b2_array_report *report, b2_artifact_error *error) { + (void)handle; (void)inputs; (void)ninputs; (void)rank; (void)shape; (void)options; (void)output; (void)capacity; (void)report; + memset(error,0,sizeof(*error)); snprintf(error->message,sizeof(error->message),"Native runtime does not support logical arrays"); return -2; +} +#endif +typedef int (*b2_array_reader)(void *, const size_t *, size_t, void *, size_t); +#ifdef B2_HAVE_ARRAY_SOURCES +typedef me_array_source b2_array_source; +static int b2_array_sources_available(void) { return 1; } +static int b2_array_eval_sources(const void *handle, const b2_array_source *inputs, int ninputs, + int rank, const int64_t *shape, const b2_array_options *options, void *output, + size_t capacity, b2_array_report *report, b2_artifact_error *error) { + return me_artifact_eval_array_sources(handle,inputs,ninputs,rank,shape,options,output,capacity,report,error); +} +#else +typedef struct { b2_array_view view; b2_array_reader read; void *owner; } b2_array_source; +static int b2_array_sources_available(void) { return 0; } +static int b2_array_eval_sources(const void *handle, const b2_array_source *inputs, int ninputs, + int rank, const int64_t *shape, const b2_array_options *options, void *output, + size_t capacity, b2_array_report *report, b2_artifact_error *error) { + (void)handle; (void)inputs; (void)ninputs; (void)rank; (void)shape; (void)options; (void)output; (void)capacity; (void)report; + memset(error,0,sizeof(*error)); snprintf(error->message,sizeof(error->message),"Native runtime does not support storage readers"); return -2; +} +#endif +#endif diff --git a/src/blosc2/dsl_artifact_bridge.h b/src/blosc2/dsl_artifact_bridge.h new file mode 100644 index 000000000..448d7bb1e --- /dev/null +++ b/src/blosc2/dsl_artifact_bridge.h @@ -0,0 +1,215 @@ +/* Copyright (c) 2026, Blosc Development Team + * SPDX-License-Identifier: BSD-3-Clause + * Optional native artifact support; old miniexpr builds remain usable. */ +#ifndef B2_DSL_ARTIFACT_BRIDGE_H +#define B2_DSL_ARTIFACT_BRIDGE_H +#include "miniexpr.h" +#include +#include + +#ifdef B2_HAVE_PORTABLE_ARTIFACT +#include "miniexpr_artifact.h" +#endif + +static int b2_artifact_options_available(void) { +#ifdef ME_ARTIFACT_LOAD_OPTIONS_VERSION + return 1; +#else + return 0; +#endif +} +static int b2_artifact_auto_jit_mode(void) { +#ifdef ME_ARTIFACT_EXECUTION_KIND_VERSION + return 3; +#else + return 0; +#endif +} +static const char *b2_artifact_execution_kind(const void *handle) { +#ifdef ME_ARTIFACT_EXECUTION_KIND_VERSION + return me_artifact_execution_kind((const me_artifact *)handle); +#else + (void)handle; + return "unknown"; +#endif +} +#if defined(B2_HAVE_PORTABLE_ARTIFACT) && defined(ME_ARTIFACT_DRAFT_SCHEMA_VERSION) +typedef me_artifact_input b2_artifact_input; +typedef me_artifact_error b2_artifact_error; +static int b2_artifact_available(void) { return !strcmp(ME_ARTIFACT_SCHEMA_VERSION, "1.0"); } +static int b2_artifact_load(const char *json, size_t size, int jit, void **out, b2_artifact_error *error) { + if (!b2_artifact_available()) { + *out = NULL; + memset(error, 0, sizeof(*error)); + snprintf(error->message, sizeof(error->message), "Build with miniexpr draft 1.0 artifact support"); + return -100; + } + me_artifact *handle = NULL; + int rc = me_artifact_load(json, size, (me_jit_mode)jit, &handle, error); + *out = handle; + return rc; +} +static int b2_artifact_eval(const void *handle, const b2_artifact_input *inputs, int ninputs, + void *output, size_t count, b2_artifact_error *error) { + return me_artifact_eval((const me_artifact *)handle, inputs, ninputs, output, count, error); +} +static void b2_artifact_free(void *handle) { me_artifact_free((me_artifact *)handle); } +static const char *b2_artifact_source(const void *handle) { return me_artifact_source(handle); } +static const char *b2_artifact_entry(const void *handle) { return me_artifact_entry_point(handle); } +static int b2_artifact_ninputs(const void *handle) { return me_artifact_ninputs(handle); } +static const char *b2_artifact_name(const void *handle, int index) { return me_artifact_input_name(handle, index); } +static me_dtype b2_artifact_dtype(const void *handle, int index) { return me_artifact_input_dtype(handle, index); } +static me_dtype b2_artifact_output(const void *handle) { return me_artifact_output_dtype(handle); } +static int b2_artifact_jit(const void *handle) { return me_artifact_has_jit(handle); } +#else +typedef struct { + const char *name; + me_dtype dtype; + const void *data; + size_t nitems; +} b2_artifact_input; +typedef struct { + int native_status; + int line; + int column; + char message[256]; +} b2_artifact_error; +static int b2_artifact_available(void) { return 0; } +static int b2_artifact_load(const char *json, size_t size, int jit, void **out, b2_artifact_error *error) { + (void)json; (void)size; (void)jit; + *out = NULL; + memset(error, 0, sizeof(*error)); + snprintf(error->message, sizeof(error->message), "Build with miniexpr portable artifact support"); + return -100; +} +static int b2_artifact_eval(const void *handle, const b2_artifact_input *inputs, int ninputs, + void *output, size_t count, b2_artifact_error *error) { + (void)handle; (void)inputs; (void)ninputs; (void)output; (void)count; (void)error; + return -100; +} +static void b2_artifact_free(void *handle) { (void)handle; } +static const char *b2_artifact_source(const void *handle) { (void)handle; return NULL; } +static const char *b2_artifact_entry(const void *handle) { (void)handle; return NULL; } +static int b2_artifact_ninputs(const void *handle) { (void)handle; return 0; } +static const char *b2_artifact_name(const void *handle, int index) { (void)handle; (void)index; return NULL; } +static me_dtype b2_artifact_dtype(const void *handle, int index) { (void)handle; (void)index; return ME_AUTO; } +static me_dtype b2_artifact_output(const void *handle) { (void)handle; return ME_AUTO; } +static int b2_artifact_jit(const void *handle) { (void)handle; return 0; } +#endif + +static int b2_artifact_load_options(const char *json, size_t size, int jit, + const me_jit_options *options, void **out, b2_artifact_error *error) { +#ifdef ME_ARTIFACT_LOAD_OPTIONS_VERSION + me_artifact *handle = NULL; + int rc = me_artifact_load_options(json, size, (me_jit_mode)jit, options, &handle, error); + *out = handle; + return rc; +#else + (void)options; + return b2_artifact_load(json, size, jit, out, error); +#endif +} +static int b2_artifact_load_inferred_available(void) { +#ifdef ME_ARTIFACT_INFER_OUTPUT_VERSION + return 1; +#else + return 0; +#endif +} +static int b2_artifact_load_inferred(const char *json, size_t size, int jit, + const me_jit_options *options, void **out, + b2_artifact_error *error) { +#ifdef ME_ARTIFACT_INFER_OUTPUT_VERSION + me_artifact *handle = NULL; + int rc = me_artifact_load_inferred_options(json, size, (me_jit_mode)jit, options, &handle, error); + *out = handle; + return rc; +#else + (void)options; + return b2_artifact_load(json, size, jit, out, error); +#endif +} +#if defined(B2_HAVE_PORTABLE_ARTIFACT) && defined(ME_ARTIFACT_DRAFT_SCHEMA_VERSION) +typedef me_artifact_buffer b2_artifact_buffer; +typedef me_artifact_eval_descriptor b2_artifact_descriptor; +static int b2_artifact_descriptor_available(void) { return b2_artifact_available(); } +static int b2_artifact_cardinality(const void *handle) { return me_artifact_result_cardinality(handle); } +static size_t b2_artifact_width(const void *handle, int index) { + return index < 0 ? me_artifact_output_itemsize(handle) : me_artifact_input_itemsize(handle, index); +} +static int b2_artifact_rank(const void *handle) { return me_artifact_context_ndim(handle); } +static const char *b2_artifact_version(const void *handle) { return me_artifact_schema_version(handle); } +#ifdef ME_ARTIFACT_MATH_POLICY_VERSION +static const char *b2_artifact_math(const void *handle) { return me_artifact_math_backend(handle); } +static const char *b2_artifact_math_ulp(const void *handle) { return me_artifact_sleef_accuracy(handle); } +static const char *b2_artifact_fp(const void *handle) { return me_artifact_fp_mode(handle); } +#else +static const char *b2_artifact_math(const void *handle) { (void)handle; return "unknown"; } +static const char *b2_artifact_math_ulp(const void *handle) { (void)handle; return ""; } +static const char *b2_artifact_fp(const void *handle) { (void)handle; return "unknown"; } +#endif +static int b2_artifact_eval_ex(const void *handle, const b2_artifact_buffer *inputs, int ninputs, + void *output, const b2_artifact_descriptor *descriptor, b2_artifact_error *error) { + return me_artifact_eval_ex(handle, inputs, ninputs, output, descriptor, error); +} +#else +typedef struct { + const char *name; + me_dtype dtype; + size_t itemsize; + const void *data; + size_t capacity; +} b2_artifact_buffer; +typedef struct { + size_t struct_size; + unsigned int version; + size_t nitems; + size_t output_capacity; + const uint8_t *valid_mask; + size_t valid_mask_capacity; + int ndim; + const int64_t *logical_shape; + const int64_t *block_origin; + const int64_t *block_extent; +} b2_artifact_descriptor; +static int b2_artifact_descriptor_available(void) { return 0; } +static int b2_artifact_cardinality(const void *handle) { (void)handle; return 0; } +static size_t b2_artifact_width(const void *handle, int index) { (void)handle; (void)index; return 0; } +static int b2_artifact_rank(const void *handle) { (void)handle; return 0; } +static const char *b2_artifact_version(const void *handle) { (void)handle; return "unsupported"; } +static const char *b2_artifact_math(const void *handle) { (void)handle; return "unknown"; } +static const char *b2_artifact_math_ulp(const void *handle) { (void)handle; return ""; } +static const char *b2_artifact_fp(const void *handle) { (void)handle; return "unknown"; } +static int b2_artifact_eval_ex(const void *handle, const b2_artifact_buffer *inputs, int ninputs, + void *output, const b2_artifact_descriptor *descriptor, b2_artifact_error *error) { + (void)handle; (void)inputs; (void)ninputs; (void)output; (void)descriptor; + memset(error, 0, sizeof(*error)); + snprintf(error->message, sizeof(error->message), "Build with draft miniexpr 1.0 descriptor support"); + return -2; +} +#endif +#ifdef ME_ARTIFACT_NUMPY_SCHEMA_VERSION +static me_dtype b2_artifact_inferred(const void *handle) { return me_artifact_inferred_dtype(handle); } +#else +static me_dtype b2_artifact_inferred(const void *handle) { (void)handle; return ME_AUTO; } +#endif +#ifdef ME_ARTIFACT_FP_STATUS_VERSION +typedef me_artifact_fp_status b2_artifact_fp_status; +static int b2_artifact_eval_status(const void *handle, const b2_artifact_buffer *inputs, int ninputs, + void *output, const b2_artifact_descriptor *descriptor, unsigned mask, + b2_artifact_fp_status *status, b2_artifact_error *error) { + return me_artifact_eval_status(handle, inputs, ninputs, output, descriptor, mask, status, error); +} +#else +typedef struct { unsigned flags; unsigned supported; } b2_artifact_fp_status; +static int b2_artifact_eval_status(const void *handle, const b2_artifact_buffer *inputs, int ninputs, + void *output, const b2_artifact_descriptor *descriptor, unsigned mask, + b2_artifact_fp_status *status, b2_artifact_error *error) { + (void)handle; (void)inputs; (void)ninputs; (void)output; (void)descriptor; (void)mask; + status->flags = status->supported = 0; + memset(error, 0, sizeof(*error)); + snprintf(error->message, sizeof(error->message), "Native runtime does not support floating status"); + return -2; +} +#endif +#endif diff --git a/src/blosc2/dsl_execution.py b/src/blosc2/dsl_execution.py new file mode 100644 index 000000000..eb2b84eeb --- /dev/null +++ b/src/blosc2/dsl_execution.py @@ -0,0 +1,191 @@ +"""Execute source-authored LazyUDF recipes using the portable Menudet runtime.""" + +import copy +import os +import re +from itertools import product + +import numpy as np + +import blosc2 + +from .portable_lazy import PortableLazyArray + + +def _compatibility_result(udf): + if getattr(udf, "_require_menudet", False): + raise NotImplementedError("This @blosc2.jit kernel requires unsupported Menudet functionality") + return False, None + + +class _PartitionedDSL(PortableLazyArray): + """Keep original chunk-local groups and broadcast scalar returns like LazyUDF.""" + + def __init__(self, kernel, inputs, shape, chunks, blocks): + super().__init__(kernel, inputs, shape=shape, partitions=blocks) + self._shape = shape + self._chunks = chunks + + def _values(self, selection=None): + if selection is None or selection is Ellipsis: + selection = () + if not isinstance(selection, tuple): + selection = (selection,) + if Ellipsis in selection: + pos = selection.index(Ellipsis) + selection = ( + selection[:pos] + + (slice(None),) * (len(self.shape) - len(selection) + 1) + + selection[pos + 1 :] + ) + selection += (slice(None),) * (len(self.shape) - len(selection)) + if len(selection) != len(self.shape): + raise IndexError("Too many indices") + indices, squeeze, groups = [], [], [] + for axis, (part, size, chunk, block) in enumerate( + zip(selection, self.shape, self._chunks, self.partitions, strict=True) + ): + if isinstance(part, int): + part = part + size if part < 0 else part + if not 0 <= part < size: + raise IndexError("Index out of range") + selected = np.array([part], dtype=np.intp) + squeeze.append(axis) + else: + selected = np.arange(*part.indices(size), dtype=np.intp) + indices.append(selected) + intervals = [] + for c in range(0, size, chunk): + for origin in range(c, min(c + chunk, size), block): + end = min(origin + block, c + chunk, size) + positions = np.flatnonzero((selected >= origin) & (selected < end)) + if positions.size: + intervals.append((origin, end, positions)) + groups.append(intervals) + result = np.empty(tuple(len(i) for i in indices), dtype=self.dtype) + for group in product(*groups): + origin = tuple(g[0] for g in group) + extent = tuple(g[1] - g[0] for g in group) + item = tuple(slice(g[0], g[1]) for g in group) + operands = {} + for name, value in self.inputs.items(): + rank = len(value.shape) + source_item = ( + tuple( + slice(0, 1) if size == 1 else part + for size, part in zip(value.shape, item[len(item) - rank :], strict=True) + ) + if rank + else () + ) + operands[name] = np.broadcast_to(np.asarray(value[source_item]), extent) + context = ( + {"logical_shape": self.shape, "block_origin": origin} if self.kernel.context_ndim else {} + ) + values = self.kernel.evaluate_block(operands, block_shape=extent, **context) + positions = tuple(g[2] for g in group) + local = tuple(i[p] - o for i, p, o in zip(indices, positions, origin, strict=True)) + result[np.ix_(*positions)] = values if np.ndim(values) == 0 else values[np.ix_(*local)] + return np.squeeze(result, axis=tuple(squeeze)) if squeeze else result + + +def evaluate_dsl_udf(udf, item, *, getitem, options): # noqa: C901 -- explicit compatibility gates + """Return (handled, result), retaining explicit compatibility exclusions.""" + from .dsl_kernel import DSLKernel + from .portable_kernel import PortableArtifactError + + if ( + not isinstance(udf.func, DSLKernel) + or getattr(udf, "_legacy_source_recipe", False) + or getattr(udf.func, "_legacy_source_recipe", False) + ): + return _compatibility_result(udf) + storage = dict(options) + execution = blosc2.jit_config.execution_options() + execution.update(blosc2.jit_config.pop_execution_options(storage)) + if blosc2.IS_WASM: + # Pyodide uses the typed interpreter: the wasm32 compiler path is not + # part of the Python wheel's qualified runtime. + execution["jit"] = False + execution["jit_backend"] = None + if ( + execution["jit_backend"] == "js" + or not blosc2.blosc2_ext.portable_descriptor_available() + or ( + any(execution[name] for name in ("compiler", "cflags", "cache_dir", "compiler_output", "trace")) + and not blosc2.blosc2_ext.portable_artifact_options_available() + ) + or np.dtype(udf.dtype).kind not in "biufcSU" + or (np.dtype(udf.dtype).kind == "f" and np.dtype(udf.dtype).itemsize not in (4, 8)) + or (np.dtype(udf.dtype).kind == "c" and np.dtype(udf.dtype).itemsize not in (8, 16)) + ): + return _compatibility_result(udf) + chunks, blocks = tuple(udf.chunks), tuple(udf.blocks) + inputs, constants = {}, {} + for name, value in zip(udf.func.input_names, udf.inputs, strict=True): + if np.isscalar(value): + constants[name] = value + else: + inputs[name] = value + # Argument defaults have already been bound by the Python call wrapper; + # the portable native grammar expects a plain parameter list. + text = re.sub( + r"(?m)^def ([^(]+)\([^\n]*\):", + lambda match: f"def {match[1]}({', '.join(udf.func.input_names)}):", + udf.func.dsl_source, + ) + from .lazyexpr import _apply_jit_backend_pragma + + text = _apply_jit_backend_pragma(text, inputs, execution["jit_backend"]) + source = copy.copy(udf.func) + source.dsl_source = text + ndim = udf.ndim if re.search(r"\b(?:_flat_idx|_ndim|_[in]\d+)\b", text) else 0 + try: + with blosc2.jit_options(**execution): + artifact = source.export( + {name: value.dtype for name, value in inputs.items()}, + udf.dtype, + constants=constants, + ndim=ndim, + ) + except PortableArtifactError as error: + if "return cardinality" in str(error): + with blosc2.jit_options(**execution): + artifact = source.export( + {name: value.dtype for name, value in inputs.items()}, + udf.dtype, + constants=constants, + ndim=ndim, + cardinality="block_scalar", + ) + else: + raise RuntimeError(f"Menudet compilation failed for DSL kernel: {error}") from error + with blosc2.jit_options(**execution): + kernel = blosc2.PortableKernel.from_json(artifact, jit=execution["jit"]) + if kernel.result_cardinality == "block_scalar": + portable = kernel.lazy(inputs, shape=tuple(udf.shape), partitions=blocks) + elif any(c % b for c, b in zip(chunks, blocks, strict=True)): + portable = _PartitionedDSL(kernel, inputs, tuple(udf.shape), chunks, blocks) + else: + portable = kernel.lazy(inputs, shape=tuple(udf.shape), partitions=blocks) + udf._native_execution_report = {"route": "menudet-lazyudf", "jit": kernel.has_jit} + if os.environ.get("BLOSC_ME_JIT_TRACE") == "1": + print(f"[blosc2] engine=menudet jit={execution['jit']} expr={text[:120]}") + if getitem: + return True, portable[item] + output = storage.pop("_output", None) + for key in ("dtype", "shape", "in_place", "strict_miniexpr"): + storage.pop(key, None) + if output is not None: + output[...] = portable[item] + return True, output + if storage.get("chunks") is None and storage.get("blocks") is None: + storage["chunks"] = chunks + storage["blocks"] = blocks + full = item is None or item is Ellipsis or (isinstance(item, tuple) and not item) + if full: + return True, portable.compute(**storage) + # Selection can change rank/shape; do not impose the original storage grid. + storage.pop("chunks", None) + storage.pop("blocks", None) + return True, portable.compute(item=item, **storage) diff --git a/src/blosc2/dsl_graph_bridge.h b/src/blosc2/dsl_graph_bridge.h new file mode 100644 index 000000000..d4cb8632d --- /dev/null +++ b/src/blosc2/dsl_graph_bridge.h @@ -0,0 +1,296 @@ +#ifndef BLOSC2_DSL_GRAPH_BRIDGE_H +#define BLOSC2_DSL_GRAPH_BRIDGE_H +#include "dsl_array_bridge.h" +typedef struct { + const char *name; + me_dtype dtype; + int rank; + int64_t shape[16]; +} b2_graph_metadata; +typedef struct { + int node, stage; + b2_artifact_error native; +} b2_graph_error; +typedef struct { + b2_array_report array; + size_t stages, jit_stages, interpreter_stages; + size_t tasks; +} b2_graph_report; +typedef void (*b2_graph_task_fn)(void *, size_t); +typedef int (*b2_graph_fork_join_fn)(void *, size_t, b2_graph_task_fn, void *); +#if defined(__APPLE__) && !defined(__EMSCRIPTEN__) +#include +typedef struct { + b2_graph_task_fn task; + void *invocation; +} b2_graph_dispatch_state; +static void b2_graph_dispatch_task(void *context, size_t index) { + b2_graph_dispatch_state *state = context; + state->task(state->invocation,index); +} +#endif +static int b2_graph_native_executor_available(void) { +#if defined(__APPLE__) && !defined(__EMSCRIPTEN__) + return 1; +#else + return 0; +#endif +} +static int b2_graph_native_fork_join(void *host, size_t count, b2_graph_task_fn task, void *invocation) { + (void)host; +#if defined(__APPLE__) && !defined(__EMSCRIPTEN__) + b2_graph_dispatch_state state = {task,invocation}; + /* dispatch_apply_f joins every native task before its invocation state expires. */ + dispatch_apply_f(count,dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0), + &state,b2_graph_dispatch_task); + return 0; +#else + (void)count; (void)task; (void)invocation; + return 1; +#endif +} +#ifdef B2_HAVE_NATIVE_GRAPH +#include "miniexpr_graph.h" +static int b2_graph_prepare(const char *json, size_t n, int jit, int required, void **out, b2_graph_error *e) { + me_graph_prepare_options options = {sizeof(options), ME_GRAPH_VERSION, (me_jit_mode)jit, required != 0, true}; + me_graph_plan *p = NULL; + me_graph_error error; + int rc = me_graph_prepare_json(json, n, &options, &p, &error); + *out = p; e->node = error.node; e->stage = error.stage; e->native = error.native; + return rc; +} +static int b2_graph_specialize(const void *p, const b2_graph_metadata *inputs, int n, size_t tile, size_t budget, + void **out, b2_graph_error *e) { + me_graph_input_metadata metadata[ME_MAX_VARS]; + if (n < 0 || n > ME_MAX_VARS) { + *out = NULL; memset(e, 0, sizeof(*e)); e->node = e->stage = -1; + snprintf(e->native.message, sizeof(e->native.message), "Native graph binding limit exceeded"); + return -5; + } + for (int i = 0; i < n; i++) { + metadata[i].name = inputs[i].name; metadata[i].dtype = inputs[i].dtype; metadata[i].rank = inputs[i].rank; + memcpy(metadata[i].shape, inputs[i].shape, sizeof(metadata[i].shape)); + } + me_graph_specialize_options options = {sizeof(options), ME_GRAPH_VERSION, tile, budget}; + me_graph_schedule *s = NULL; me_graph_error error; + int rc = me_graph_specialize(p, metadata, n, &options, &s, &error); + *out = s; e->node = error.node; e->stage = error.stage; e->native = error.native; + return rc; +} +static int b2_graph_prepare_text(const char *text, size_t length, const b2_graph_metadata *inputs, + int n, int jit, int required, void **out, b2_graph_error *e) { + me_graph_input_metadata metadata[ME_MAX_VARS] = {0}; + if (n < 0 || n > ME_MAX_VARS) { + *out = NULL; memset(e, 0, sizeof(*e)); e->node = e->stage = -1; + snprintf(e->native.message, sizeof(e->native.message), "Native graph binding limit exceeded"); + return -5; + } + for (int i = 0; i < n; i++) { metadata[i].name = inputs[i].name; metadata[i].dtype = inputs[i].dtype; } + me_graph_prepare_options options = {sizeof(options), ME_GRAPH_VERSION, (me_jit_mode)jit, required != 0, true}; + me_graph_plan *p = NULL; me_graph_error error; + int rc = me_graph_prepare_expression(text, length, metadata, n, &options, &p, &error); + *out = p; e->node = error.node; e->stage = error.stage; e->native = error.native; + return rc; +} +static int b2_graph_execute(const void *s, const b2_array_view *inputs, int n, void *out, size_t bytes, + unsigned raise_mask, b2_graph_report *report, b2_graph_error *e) { + me_graph_execute_options options = {sizeof(options), ME_GRAPH_VERSION, raise_mask}; + me_graph_report result; me_graph_error error; + int rc = me_graph_execute(s, inputs, n, out, bytes, &options, &result, &error); + report->array = result.array; + report->stages = result.stages; +#ifdef ME_GRAPH_STAGED_FORMAT + report->jit_stages = result.jit_stages; + report->interpreter_stages = result.interpreter_stages; +#else + report->jit_stages = result.has_jit ? 1 : 0; + report->interpreter_stages = result.stages - report->jit_stages; +#endif + e->node = error.node; e->stage = error.stage; e->native = error.native; + return rc; +} +static void b2_graph_free(void *p) { me_graph_plan_free(p); } +static void b2_graph_schedule_free(void *s) { me_graph_schedule_free(s); } +static int b2_graph_ninputs(const void *p) { return me_graph_ninputs(p); } +static const char *b2_graph_name(const void *p, int i) { return me_graph_input_name(p, i); } +static me_dtype b2_graph_dtype(const void *p, int i) { return me_graph_input_dtype(p, i); } +static me_dtype b2_graph_inferred(const void *p) { return me_graph_inferred_dtype(p); } +static int b2_graph_jit(const void *p) { return me_graph_has_jit(p); } +static const char *b2_graph_reduction_op(const void *p) { return me_graph_reduction_op(p); } +static int b2_graph_reduction_axis_count(const void *p) { return me_graph_reduction_axis_count(p); } +static int b2_graph_reduction_axis(const void *p, int index) { return me_graph_reduction_axis(p, index); } +static int b2_graph_reduction_keepdims(const void *p) { return me_graph_reduction_keepdims(p); } +static int b2_graph_reduction_has_initial(const void *p) { return me_graph_reduction_has_initial(p); } +static int b2_graph_reduction_has_where(const void *p) { return me_graph_reduction_has_where(p); } +static const char *b2_graph_json(const void *p) { return me_graph_export_json(p, NULL); } +static const char *b2_graph_map_json(const void *p) { return me_graph_export_map_json(p); } +static const void *b2_graph_map_artifact(const void *p) { return me_graph_map_artifact(p); } +static size_t b2_graph_stages(const void *p) { return me_graph_stage_count(p); } +static size_t b2_graph_intermediate(const void *s) { return me_graph_intermediate_bytes(s); } +static size_t b2_graph_plan_bytes(const void *p) { return me_graph_plan_bytes(p); } +static size_t b2_graph_schedule_bytes(const void *s) { return me_graph_schedule_bytes(s); } +static size_t b2_graph_scratch(const void *s) { return me_graph_scratch_bytes(s); } +static int b2_graph_stage_info(const void *s, int stage, int64_t *shape, me_dtype *dtype, + size_t *bytes, int *last) { +#ifdef ME_GRAPH_STAGED_FORMAT + int rank = me_graph_stage_output_rank(s, stage); + if (rank >= 0) memcpy(shape, me_graph_stage_output_shape(s, stage), rank * sizeof(*shape)); + *dtype = me_graph_stage_output_dtype(s, stage); + *bytes = me_graph_stage_output_bytes(s, stage); + /* Last consumer is queried through the retaining schedule's plan below. */ + *last = me_graph_schedule_stage_last_consumer(s, stage); + return rank; +#else + (void)s; (void)stage; (void)shape; (void)dtype; (void)bytes; (void)last; + return -1; +#endif +} +static int b2_graph_shape(const void *s, int64_t *shape, me_dtype *dtype) { + int rank = me_graph_output_rank(s); + if (rank >= 0) memcpy(shape, me_graph_output_shape(s), rank * sizeof(*shape)); + *dtype = me_graph_output_dtype(s); return rank; +} +static int b2_graph_map_shape(const void *s, int64_t *shape) { + int rank; const int64_t *value = me_graph_map_shape(s, &rank); + if (rank >= 0) memcpy(shape, value, rank * sizeof(*shape)); + return rank; +} +#else +static int b2_graph_prepare(const char *json, size_t n, int jit, int required, void **out, b2_graph_error *e) { + (void)json; (void)n; (void)jit; (void)required; *out = NULL; memset(e, 0, sizeof(*e)); + snprintf(e->native.message, sizeof(e->native.message), "Build with miniexpr native graph preparation support"); return -100; +} +static int b2_graph_specialize(const void *p, const b2_graph_metadata *inputs, int n, size_t tile, size_t budget, void **out, b2_graph_error *e) { + (void)p; (void)inputs; (void)n; (void)tile; (void)budget; (void)e; *out = NULL; return -100; +} +static int b2_graph_prepare_text(const char *text, size_t length, const b2_graph_metadata *inputs, + int n, int jit, int required, void **out, b2_graph_error *e) { + (void)text; (void)length; (void)inputs; (void)n; (void)jit; (void)required; (void)e; *out = NULL; return -100; +} +static int b2_graph_execute(const void *s, const b2_array_view *inputs, int n, void *out, size_t bytes, + unsigned raise_mask, b2_graph_report *report, b2_graph_error *e) { + (void)s; (void)inputs; (void)n; (void)out; (void)bytes; (void)raise_mask; (void)report; (void)e; return -100; +} +static void b2_graph_free(void *p) { (void)p; } +static void b2_graph_schedule_free(void *s) { (void)s; } +static int b2_graph_ninputs(const void *p) { (void)p; return 0; } +static const char *b2_graph_name(const void *p, int i) { (void)p; (void)i; return NULL; } +static me_dtype b2_graph_dtype(const void *p, int i) { (void)p; (void)i; return ME_AUTO; } +static me_dtype b2_graph_inferred(const void *p) { (void)p; return ME_AUTO; } +static int b2_graph_jit(const void *p) { (void)p; return 0; } +static const char *b2_graph_reduction_op(const void *p) { (void)p; return NULL; } +static int b2_graph_reduction_axis_count(const void *p) { (void)p; return 0; } +static int b2_graph_reduction_axis(const void *p, int index) { (void)p; (void)index; return 0; } +static int b2_graph_reduction_keepdims(const void *p) { (void)p; return 0; } +static int b2_graph_reduction_has_initial(const void *p) { (void)p; return 0; } +static int b2_graph_reduction_has_where(const void *p) { (void)p; return 0; } +static const char *b2_graph_json(const void *p) { (void)p; return NULL; } +static const char *b2_graph_map_json(const void *p) { (void)p; return NULL; } +static const void *b2_graph_map_artifact(const void *p) { (void)p; return NULL; } +static size_t b2_graph_stages(const void *p) { (void)p; return 0; } +static size_t b2_graph_intermediate(const void *s) { (void)s; return 0; } +static size_t b2_graph_plan_bytes(const void *p) { (void)p; return 0; } +static size_t b2_graph_schedule_bytes(const void *s) { (void)s; return 0; } +static size_t b2_graph_scratch(const void *s) { (void)s; return 0; } +static int b2_graph_stage_info(const void *s, int stage, int64_t *shape, me_dtype *dtype, + size_t *bytes, int *last) { + (void)s; (void)stage; (void)shape; (void)dtype; (void)bytes; (void)last; return -1; +} +static int b2_graph_shape(const void *s, int64_t *shape, me_dtype *dtype) { (void)s; (void)shape; *dtype = ME_AUTO; return -1; } +static int b2_graph_map_shape(const void *s, int64_t *shape) { (void)s; (void)shape; return -1; } +#endif +/* New destination contracts are capability-gated for independently installed + * older miniexpr runtimes. The view carries allocation bounds, not logical bytes. */ +static int b2_graph_output_available(void) { +#if defined(B2_HAVE_NATIVE_GRAPH) && defined(ME_ARRAY_OUTPUT_VERSION) + return 1; +#else + return 0; +#endif +} +static int b2_graph_execute_into(const void *s, const b2_array_view *inputs, + const b2_array_source *sources, int n, const b2_array_view *out, + unsigned raise_mask, b2_graph_report *report, b2_graph_error *e) { +#if defined(B2_HAVE_NATIVE_GRAPH) && defined(ME_ARRAY_OUTPUT_VERSION) + me_array_output destination = {0}; + destination.struct_size = sizeof(destination); destination.version = ME_ARRAY_OUTPUT_VERSION; + destination.dtype = out->dtype; destination.base = (void *)out->base; + destination.capacity = out->capacity; destination.offset = out->offset; destination.rank = out->rank; + memcpy(destination.shape,out->shape,sizeof(destination.shape)); + memcpy(destination.strides,out->strides,sizeof(destination.strides)); + me_graph_execute_options options = {sizeof(options), ME_GRAPH_VERSION, raise_mask}; + me_graph_report result = {0}; me_graph_error error = {0}; + int rc = sources ? me_graph_execute_sources_into(s,sources,n,&destination,&options,&result,&error) : + me_graph_execute_into(s,inputs,n,&destination,&options,&result,&error); + report->array = result.array; report->stages = result.stages; + report->jit_stages = result.jit_stages; report->interpreter_stages = result.interpreter_stages; + e->node = error.node; e->stage = error.stage; e->native = error.native; + return rc; +#else + (void)s; (void)inputs; (void)sources; (void)n; (void)out; (void)raise_mask; (void)report; (void)e; + return -100; +#endif +} +static unsigned b2_graph_execution_capabilities(const void *p) { +#if defined(B2_HAVE_NATIVE_GRAPH) && defined(ME_GRAPH_EXECUTOR_VERSION) + return me_graph_execution_capabilities(p); +#else + (void)p; return 0; +#endif +} +static int b2_graph_execute_parallel_into(const void *s, const b2_array_view *inputs, + int n, const b2_array_view *out, unsigned raise_mask, size_t workers, + b2_graph_fork_join_fn fork_join, void *host, b2_graph_report *report, b2_graph_error *e) { +#if defined(B2_HAVE_NATIVE_GRAPH) && defined(ME_GRAPH_EXECUTOR_VERSION) + me_array_output destination = {0}; + destination.struct_size=sizeof(destination); destination.version=ME_ARRAY_OUTPUT_VERSION; + destination.dtype=out->dtype; destination.base=(void *)out->base; + destination.capacity=out->capacity; destination.offset=out->offset; destination.rank=out->rank; + memcpy(destination.shape,out->shape,sizeof(destination.shape)); + memcpy(destination.strides,out->strides,sizeof(destination.strides)); + me_graph_execute_options options={sizeof(options),ME_GRAPH_VERSION,raise_mask}; + me_graph_executor executor={sizeof(executor),ME_GRAPH_EXECUTOR_VERSION,workers,0,fork_join,host,0,0}; + me_graph_parallel_report result={0}; me_graph_error error={0}; + int rc=me_graph_execute_parallel_into(s,inputs,n,&destination,&options,&executor,&result,&error); + report->array=result.execution.array; report->stages=result.execution.stages; + report->jit_stages=result.execution.jit_stages; report->interpreter_stages=result.execution.interpreter_stages; + report->tasks=result.tasks; + e->node=error.node; e->stage=error.stage; e->native=error.native; + return rc; +#else + (void)workers; (void)fork_join; (void)host; + return b2_graph_execute_into(s,inputs,NULL,n,out,raise_mask,report,e); +#endif +} +static int b2_graph_sources_available(void) { +#ifdef B2_HAVE_GRAPH_SOURCES + return 1; +#else + return 0; +#endif +} +static int b2_graph_execute_sources(const void *s, const b2_array_source *inputs, int n, + void *out, size_t bytes, unsigned raise_mask, b2_graph_report *report, b2_graph_error *e) { +#ifdef B2_HAVE_GRAPH_SOURCES + me_graph_execute_options options = {sizeof(options), ME_GRAPH_VERSION, raise_mask}; + me_graph_report result = {0}; me_graph_error error = {0}; + int rc = me_graph_execute_sources(s, inputs, n, out, bytes, &options, &result, &error); + report->array = result.array; + report->stages = result.stages; +#ifdef ME_GRAPH_STAGED_FORMAT + report->jit_stages = result.jit_stages; + report->interpreter_stages = result.interpreter_stages; +#else + report->jit_stages = result.has_jit ? 1 : 0; + report->interpreter_stages = result.stages - report->jit_stages; +#endif + e->node = error.node; e->stage = error.stage; e->native = error.native; + return rc; +#else + (void)s; (void)inputs; (void)n; (void)out; (void)bytes; (void)raise_mask; + memset(report, 0, sizeof(*report)); memset(e, 0, sizeof(*e)); + snprintf(e->native.message, sizeof(e->native.message), "Native runtime does not support graph storage readers"); + return -100; +#endif +} +#endif diff --git a/src/blosc2/dsl_kernel.py b/src/blosc2/dsl_kernel.py index b19f1965a..ea61b6a69 100644 --- a/src/blosc2/dsl_kernel.py +++ b/src/blosc2/dsl_kernel.py @@ -229,7 +229,11 @@ def visit_Call(self, node: ast.Call) -> ast.AST: and isinstance(func.value, ast.Name) and func.value.id in self._aliases ): - dsl_name = _NUMPY_TO_DSL_FUNC_ALIASES.get(func.attr, func.attr) + from .utils import MINIEXPR_FUNCTION_ALIASES + + dsl_name = _NUMPY_TO_DSL_FUNC_ALIASES.get( + func.attr, MINIEXPR_FUNCTION_ALIASES.get(func.attr, func.attr) + ) node.func = ast.copy_location(ast.Name(id=dsl_name, ctx=ast.Load()), func) self.rewrote_any = True return node @@ -689,7 +693,66 @@ def _cmpop(self, op: ast.cmpop): class DSLKernel: - """Wrap a Python function and optionally extract a miniexpr DSL kernel from it.""" + """Wrap a Python function, or construct a native-only kernel with ``from_source``.""" + + @classmethod + def from_source(cls, source: str) -> DSLKernel: + """Construct a native-only kernel without executing Python source. + + Preserve the source, including header pragmas, verbatim. Only the function + header is inspected here; miniexpr validates the body when compiling with + the input and output dtypes supplied to :func:`blosc2.lazyudf`. + No frontend rewriting, captured globals, or Python fallback is provided. + This accepts native DSL source, not a portable-profile certification. + """ + if not isinstance(source, str): + raise TypeError("DSL source must be a string") + if "\x00" in source: + raise ValueError("Native DSL source must not contain NUL characters") + try: + tokens = list(tokenize.generate_tokens(StringIO(source).readline)) + first = next(t for t in tokens if t.type not in (tokenize.COMMENT, tokenize.NL)) + if first.type != tokenize.NAME or first.string != "def": + raise ValueError("DSL source must start with a function definition") + _, _, colon = _find_def_signature_span(source) + if colon is None: + raise ValueError("DSL source requires a function header") + lines = source.splitlines(keepends=True) + header = "".join(lines[: colon.end[0] - 1]) + lines[colon.end[0] - 1][: colon.end[1]] + function = ast.parse(header + "\n pass\n").body[0] + args = function.args + if ( + args.posonlyargs + or args.vararg + or args.kwarg + or args.kwonlyargs + or args.defaults + or args.kw_defaults + or function.returns + or any(arg.annotation for arg in args.args) + ): + raise ValueError("Native DSL parameters must be plain positional names") + names = [arg.arg for arg in args.args] + if len(set(names)) != len(names): + raise ValueError("Native DSL parameter names must be unique") + except (SyntaxError, tokenize.TokenError, IndentationError, StopIteration) as error: + raise ValueError(f"Invalid native DSL function header: {error}") from error + + kernel = cls.__new__(cls) + kernel.func = None + kernel.__name__ = kernel.__qualname__ = function.name + kernel.__doc__ = None + kernel._sig = None + kernel._sig_has_varargs = False + kernel._sig_npositional = len(names) + kernel._legacy_udf_signature = False + from .utils import canonicalize_miniexpr_functions + + kernel.dsl_source = canonicalize_miniexpr_functions(source) + kernel.input_names = names + kernel.dsl_error = None + kernel.row_param = kernel.row_columns = None + return kernel def __init__(self, func): self.func = func @@ -734,7 +797,9 @@ def __init__(self, func): dsl_source = None input_names = None self.dsl_error = e - self.dsl_source = dsl_source + from .utils import canonicalize_miniexpr_functions + + self.dsl_source = canonicalize_miniexpr_functions(dsl_source) if dsl_source is not None else None self.input_names = input_names def _extract_dsl(self, func, validate: bool = True): @@ -833,12 +898,17 @@ def _rewrite_numpy_attr_calls(func, dsl_source, dsl_tree, dsl_func, input_names) any alias, including a bare `numpy` import, is honored). The DSL grammar only accepts bare function-name calls. No-op, returning the inputs unchanged, when there is nothing to rewrite (including when the alias is - shadowed by one of the kernel's own parameter names). + shadowed by a parameter, local, or closure binding). """ + code = getattr(func, "__code__", None) + shadowed = set(input_names) + if code is not None: + shadowed.update(code.co_varnames) + shadowed.update(code.co_freevars) aliases = { name for name, value in getattr(func, "__globals__", {}).items() - if value is numpy and name not in input_names + if value is numpy and name not in shadowed } if not aliases: return dsl_source, dsl_tree, dsl_func @@ -872,7 +942,62 @@ def _input_names_from_signature(func_node: ast.FunctionDef) -> list[str]: raise ValueError("DSL kernel does not support *args/**kwargs/kwonly args") return [a.arg for a in (args.posonlyargs + args.args)] + def export( + self, + input_dtypes, + output_dtype, + *, + capture_dtypes=None, + constants=None, + metadata=None, + version="1.0", + casting="unsafe", + cardinality="elementwise", + ndim=0, + ): + """Export a typed Menudet JSON artifact without calling the Python function. + + ``input_dtypes`` maps runtime parameter names to explicit logical dtypes. + Optional ``constants`` supplies scalar values for remaining parameters. + Globals/closure scalars are snapshotted at export and become explicit, + collision-free parameters. ``capture_dtypes`` overrides scalar type + inference (Python bool/int/float infer bool/int64/float64 respectively; + supported NumPy scalars retain their dtype). Arrays, objects, and external + callbacks cannot be captures. Import via :meth:`blosc2.PortableKernel.from_json`. + + Menudet ``version="1.0"`` is an experimental implementation draft with + NumPy-style arithmetic and optional JIT. Final output supports + ``casting="safe"``, ``"same_kind"`` or ``"unsafe"``. Numeric captures follow + the declared scalar category: + ordinary numeric captures are weak scalars; NumPy scalars and explicit + ``capture_dtypes`` are strong typed scalars. + Menudet supports mixed numeric types and fixed byte/Unicode snapshots; + ``cardinality`` is ``elementwise`` or ``block_scalar``, and ``ndim`` + declares the required logical coordinate rank. Source header pragmas + (``me:fp``, ``me:compiler``, ``me:math``, ``me:ulp``) are preserved in the + artifact. Omitted policy fields stay inheritance requests resolved by the + importer's environment; environment-derived choices are never baked into + exported source. The native loader validates normalized source, widths, + policy and cardinality before export succeeds. + """ + from .portable_kernel import export_portable_kernel + + return export_portable_kernel( + self, + input_dtypes, + output_dtype, + capture_dtypes=capture_dtypes, + constants=constants, + metadata=metadata, + version=version, + casting=casting, + cardinality=cardinality, + ndim=ndim, + ) + def __call__(self, inputs_tuple, output, offset=None): + if self.func is None: + raise RuntimeError("A native-source DSL kernel cannot execute as a Python function") if self.dsl_error is not None: raise self.dsl_error if self._legacy_udf_signature: @@ -962,6 +1087,65 @@ def validate_dsl(func): } +def validate_portable_dsl( + source, input_dtypes, output_dtype, *, language_version="1.0", ndim=0, cardinality=None +): + """Check raw native source and an exact typed signature against the Menudet 1.0 profile. + + Return a dictionary with ``valid``, ``status``, ``line``, ``column``, and + ``error``. Validation neither executes a kernel nor invokes a JIT compiler. + It does not normalize frontend syntax, inspect globals, or certify runtime + input ranges, target compatibility, or sandbox safety. Native support is + required; older builds report ``runtime_unsupported`` without Python fallback. + + ``input_dtypes`` maps parameter names to explicit dtype descriptions. Parameter + binding is by name; mapping order may differ from source order. Dtypes describe + logical values, not the storage layout of any actual input arrays. + The default ``language_version="1.0"`` is an experimental implementation + draft admitting mixed numeric and fixed-width ``S``/``U`` + signatures. ``ndim`` declares the logical rank for reserved ND symbols; + missing or insufficient context rejects explicitly. ``cardinality`` may be + ``elementwise`` or ``block_scalar`` to assert the native return contract; + None validates the inferred contract. Neither arrays nor an artifact JSON + loader are needed. Exact string output width is checked natively. + """ + from collections.abc import Mapping + + from . import blosc2_ext + + if not isinstance(source, str) or not isinstance(language_version, str): + raise TypeError("source and language_version must be strings") + if not isinstance(input_dtypes, Mapping): + raise TypeError("input_dtypes must map parameter names to explicit dtypes") + if "\x00" in source or "\x00" in language_version: + raise ValueError("Menudet source and version must not contain NUL characters") + if language_version != "1.0": + return { + "valid": False, + "status": "unsupported_version", + "line": 0, + "column": 0, + "error": "Unsupported Menudet version; expected draft 1.0", + } + if any(not isinstance(name, str) or "\x00" in name for name in input_dtypes): + raise ValueError("Menudet input names must be strings without NUL characters") + if type(ndim) is not int or not 0 <= ndim <= 2**31 - 1: + raise ValueError("ndim must be a nonnegative Python integer representable by the native API") + contracts = {None: 0, "elementwise": 1, "block_scalar": 2} + if cardinality not in contracts: + raise ValueError("cardinality must be None, 'elementwise' or 'block_scalar'") + validator = getattr(blosc2_ext, "validate_portable_dsl_source", None) + if validator is None: + return { + "valid": False, + "status": "runtime_unsupported", + "line": 0, + "column": 0, + "error": "Rebuild miniexpr and the extension with Menudet validation support", + } + return validator(source, input_dtypes, output_dtype, language_version, ndim, contracts[cardinality]) + + def validate_dsl_jit(func, operands, out_dtype, *, shape=(64,), chunks=None, blocks=None): """Report whether a DSL kernel JIT-compiles (vs. interpreter fallback). diff --git a/src/blosc2/embed_store.py b/src/blosc2/embed_store.py index e91abacc7..582a3c265 100644 --- a/src/blosc2/embed_store.py +++ b/src/blosc2/embed_store.py @@ -273,6 +273,9 @@ def __setitem__( self, key: str, value: blosc2.Array | SChunk | blosc2.ObjectArray | blosc2.BatchArray ) -> None: """Add a node to the embed store.""" + from blosc2.b2objects import preflight_persistence + + preflight_persistence(value) if self.mode == "r": raise ValueError("Cannot set items in read-only mode.") with self._write_bracket(): diff --git a/src/blosc2/exceptions.py b/src/blosc2/exceptions.py index 8faae5d52..7854a8a4b 100644 --- a/src/blosc2/exceptions.py +++ b/src/blosc2/exceptions.py @@ -18,12 +18,14 @@ def __init__(self, expr, missing_ops): class UnsafeDeserializationError(ValueError): """Raised when safe deserialization encounters an active serialized value.""" - def __init__(self, kind: str, *, location: str | None = None): + def __init__(self, kind: str, *, location: str | None = None, hint: str | None = None): where = f" in {location}" if location else "" - super().__init__( - f"Encountered active serialized value {kind!r}{where} while using " - "deserialize='safe'. Reopen with deserialize='full' only if you trust " + advice = hint or ( + "Reopen with deserialize='full' only if you trust " "this data and intend to allow reference resolution and lazy-object reconstruction." ) + super().__init__( + f"Encountered active serialized value {kind!r}{where} while using deserialize='safe'. {advice}" + ) self.kind = kind self.location = location diff --git a/src/blosc2/expression_graph.py b/src/blosc2/expression_graph.py new file mode 100644 index 000000000..a8eb3e707 --- /dev/null +++ b/src/blosc2/expression_graph.py @@ -0,0 +1,2042 @@ +"""Validated numerical expression graphs; no Python-source execution. + +The registry is deliberately independent of the public NumPy/Blosc2 namespaces. +Graph parsing is cached, while evaluation results never survive an execution. +""" + +from __future__ import annotations + +import _thread +import abc +import ast +import contextlib +import contextvars +import functools +import math +import operator +import sys +from collections import OrderedDict +from dataclasses import dataclass, field + +import numpy as np + +from blosc2.exceptions import UnsafeDeserializationError + +_mode = contextvars.ContextVar("expression_evaluation", default="full") +_active_operands = contextvars.ContextVar("expression_operand_validation", default=frozenset()) +_active_recipes = contextvars.ContextVar("expression_recipe_resolution", default=()) +_NUMPY_VALUE_PROMOTION = np.lib.NumpyVersion(np.__version__) < "2.0.0" +_BLOSC_PLATFORM_ACCUMULATOR_FALLBACK = ( + sys.platform in {"emscripten", "wasi"} and np.dtype(np.intp).itemsize < 8 +) + + +def bounded_recipe(func): + """Bound nested recipes, including reference cycles spanning multiple files.""" + + @functools.wraps(func) + def wrapped(payload, *args, **kwargs): + carrier = kwargs.get("carrier") + schunk = getattr(carrier, "schunk", carrier) + path = getattr(schunk, "urlpath", None) + key = ("path", str(path)) if path is not None else ("inline", id(payload)) + active = _active_recipes.get() + if key in active or len(active) >= 64: + _reject("cyclic or excessively deep saved expression recipes") + token = _active_recipes.set((*active, key)) + try: + return func(payload, *args, **kwargs) + finally: + _active_recipes.reset(token) + + return wrapped + + +@contextlib.contextmanager +def expression_evaluation(mode="safe"): + """Select safe graph or trusted legacy expression evaluation in this context. + + ``full`` permits Python text evaluation and must only be used with trusted + expressions and operands. It is not a process sandbox. + """ + if mode not in ("safe", "full"): + raise ValueError("Expression evaluation must be 'safe' or 'full'") + token = _mode.set(mode) + try: + yield + finally: + _mode.reset(token) + + +def evaluation_mode(): + return _mode.get() + + +def select_evaluation(text, operands, permission): + """Full permission does not make an approved graph require legacy execution.""" + if permission == "safe": + return "safe" + try: + graph = parse_expression(text) + admitted = normalize_operands(operands) + with expression_evaluation("safe"): + validate_operands(admitted) + graph.bind_root_reduction(admitted) + except (UnsafeDeserializationError, ValueError): + return "full" + return "safe" + + +def expression_method(func): + """Restore a constructed expression's execution policy for deferred work.""" + + @functools.wraps(func) + def wrapped(self, *args, **kwargs): + mode = "safe" if evaluation_mode() == "safe" else getattr(self, "_evaluation", "full") + with expression_evaluation(mode): + if evaluation_mode() == "safe": + self._graph = parse_expression(self.expression) + self.operands = normalize_operands(self.operands) + validate_operands(self.operands) + validate_operands(getattr(self, "_where_args", {})) + refresh_expression_metadata(self) + return func(self, *args, **kwargs) + + return wrapped + + +def expression_constructor(func): + """Carry a safe dependency's boundary through programmatic composition.""" + + @functools.wraps(func) + def wrapped(self, new_op): + import blosc2 + + values = () if new_op is None else (new_op[0], new_op[2]) + safe = evaluation_mode() == "safe" or any( + type(value) is blosc2.LazyExpr and getattr(value, "_evaluation", "full") == "safe" + for value in values + ) + mode = "safe" if safe else "full" + with expression_evaluation(mode): + if safe: + validate_operands(dict(enumerate(values))) + self._evaluation = mode + result = func(self, new_op) + if safe and self.expression: + record_expression_metadata(self) + return result + + return wrapped + + +def _operand_metadata(value): + """Fingerprint admitted metadata, not array data or computed results.""" + import blosc2 + + if type(value) in (tuple, list): + return (type(value), tuple(_operand_metadata(item) for item in value)) + if type(value) is type: + return (type, value) + if type(value) is blosc2.LazyExpr: + return (id(value), _expression_metadata(value)) + if type(value) is blosc2.SimpleProxy: + return (id(value), _operand_metadata(value._src)) + if hasattr(value, "dtype") and hasattr(value, "shape"): + return ( + id(value), + np.dtype(value.dtype), + tuple(value.shape), + getattr(value, "chunks", None), + getattr(value, "blocks", None), + ) + return (type(value), repr(value)) + + +def _expression_metadata(expr): + return ( + expr.expression, + tuple((name, _operand_metadata(value)) for name, value in expr.operands.items()), + tuple((name, _operand_metadata(value)) for name, value in getattr(expr, "_where_args", {}).items()), + ) + + +def record_expression_metadata(expr): + """Record the inputs for which constructor-provided metadata is valid.""" + expr._graph_metadata = _expression_metadata(expr) + + +def refresh_expression_metadata(expr): + """Re-infer safe metadata after changes using the existing validated constructor. + + No operand values are cached. Ordinary trusted expressions keep their existing + mutation behavior. This is cache invalidation, not a new inference engine. + """ + state = _expression_metadata(expr) + previous = getattr(expr, "_graph_metadata", None) + if previous is None and getattr(expr, "_evaluation", "full") == "safe": + expr._graph_metadata = state + return + if previous == state: + return + import blosc2 + + rebuilt = blosc2.LazyExpr._new_expr(expr.expression, expr.operands, guess=True) + where = getattr(expr, "_where_args", {}) + if where: + rebuilt = rebuilt.where(where["_where_x"], where.get("_where_y")) + # Commit caches only after complete replacement metadata has been inferred. + # On failure the changed signature prevents reuse of the old caches. + dtype, shape = rebuilt.dtype, rebuilt.shape + for name in ( + "_dtype", + "_dtype_", + "_shape", + "_shape_", + "_expression_", + "_chunks", + "_blocks", + "_me_str_dtype_", + "_me_str_key_", + "cons_cache", + "expression_tosave", + "operands_tosave", + ): + expr.__dict__.pop(name, None) + expr._dtype, expr._shape = dtype, shape + expr._graph_metadata = state + + +_ELEMENTWISE = frozenset( + [ + "abs", + "acos", + "acosh", + "add", + "arccos", + "arccosh", + "arcsin", + "arcsinh", + "arctan", + "arctan2", + "arctanh", + "asin", + "asinh", + "atan", + "atan2", + "atanh", + "bitwise_and", + "bitwise_invert", + "bitwise_left_shift", + "bitwise_or", + "bitwise_right_shift", + "bitwise_xor", + "broadcast_to", + "ceil", + "clip", + "complex", + "conj", + "contains", + "copysign", + "cos", + "cosh", + "divide", + "endswith", + "equal", + "exp", + "expm1", + "floor", + "floor_divide", + "fmod", + "greater", + "greater_equal", + "hypot", + "imag", + "isfinite", + "isinf", + "isnan", + "less_equal", + "less", + "log", + "log1p", + "log2", + "log10", + "logaddexp", + "logical_and", + "logical_not", + "logical_or", + "logical_xor", + "lower", + "maximum", + "minimum", + "multiply", + "negative", + "nextafter", + "not_equal", + "positive", + "pow", + "real", + "reciprocal", + "remainder", + "round", + "sign", + "signbit", + "sin", + "sinh", + "sqrt", + "square", + "startswith", + "subtract", + "tan", + "tanh", + "trunc", + "upper", + "where", + ] +) +_REDUCTIONS = frozenset( + [ + "sum", + "prod", + "min", + "max", + "std", + "mean", + "var", + "any", + "all", + "count_nonzero", + "argmax", + "argmin", + "cumulative_sum", + "cumulative_prod", + "cumsum", + "cumprod", + ] +) +_SHAPES = frozenset( + [ + "concat", + "diagonal", + "expand_dims", + "matmul", + "matrix_transpose", + "outer", + "permute_dims", + "squeeze", + "stack", + "tensordot", + "transpose", + "vecdot", + "reshape", + "copy", + "flatten", + "ravel", + ] +) +_CONSTRUCTORS = frozenset( + [ + "asarray", + "arange", + "linspace", + "zeros", + "ones", + "empty", + "full", + "frombuffer", + "full_like", + "zeros_like", + "ones_like", + "empty_like", + "eye", + "nans", + "uninit", + "meshgrid", + ] +) +_DTYPES = frozenset( + [ + "int8", + "int16", + "int32", + "int64", + "uint8", + "uint16", + "uint32", + "uint64", + "float16", + "float32", + "float64", + "complex64", + "complex128", + "bool", + "str", + "bytes", + ] +) +_CALLS = _ELEMENTWISE | _REDUCTIONS | _SHAPES | _CONSTRUCTORS | _DTYPES | {"slice", "len"} +_METHODS = _REDUCTIONS | _SHAPES | {"astype", "slice", "where"} +_ATTRIBUTES = {"T", "mT", "shape", "size", "ndim", "itemsize", "real", "imag"} +_KEYWORDS = frozenset( + [ + "axis", + "axes", + "keepdims", + "dtype", + "ddof", + "correction", + "initial", + "include_initial", + "where", + "ord", + "offset", + "axis1", + "axis2", + "shape", + "newshape", + "order", + "casting", + "copy", + "start", + "stop", + "step", + "num", + "endpoint", + "retstep", + "count", + "N", + "M", + "k", + "indexing", + "chunks", + "blocks", + "decimals", + "min", + "max", + "a_min", + "a_max", + "out", + ] +) +_BINARY = { + ast.Add: operator.add, + ast.Sub: operator.sub, + ast.Mult: operator.mul, + ast.Div: operator.truediv, + ast.FloorDiv: operator.floordiv, + ast.Mod: operator.mod, + ast.Pow: operator.pow, + ast.BitAnd: operator.and_, + ast.BitOr: operator.or_, + ast.BitXor: operator.xor, + ast.LShift: operator.lshift, + ast.RShift: operator.rshift, + ast.MatMult: operator.matmul, +} +_UNARY = { + ast.UAdd: operator.pos, + ast.USub: operator.neg, + ast.Invert: operator.invert, + ast.Not: operator.not_, +} +_COMPARE = { + ast.Eq: operator.eq, + ast.NotEq: operator.ne, + ast.Lt: operator.lt, + ast.LtE: operator.le, + ast.Gt: operator.gt, + ast.GtE: operator.ge, +} +_NP_SCALARS = frozenset(np.sctypeDict.values()) +_DTYPE_TYPES = frozenset(np.dtype(name).type for name in _DTYPES) +_DTYPE_METADATA_TYPES = frozenset(type(np.dtype(scalar)) for scalar in _NP_SCALARS) +_BINARY_CALLS = frozenset( + [ + "add", + "arctan2", + "atan2", + "bitwise_and", + "bitwise_left_shift", + "bitwise_or", + "bitwise_right_shift", + "bitwise_xor", + "copysign", + "complex", + "divide", + "endswith", + "equal", + "floor_divide", + "fmod", + "greater", + "greater_equal", + "hypot", + "less_equal", + "less", + "logaddexp", + "logical_and", + "logical_or", + "logical_xor", + "maximum", + "minimum", + "multiply", + "nextafter", + "not_equal", + "pow", + "remainder", + "startswith", + "subtract", + "contains", + "broadcast_to", + ] +) + + +# Reviewed keyword contracts shared by parsing and direct dispatch. Positional +# layouts still depend on NumPy versus Blosc2 receiver semantics; do not silently +# reinterpret those layouts as one new numerical API. +_REDUCTION_KEYWORDS = { + "sum": frozenset({"axis", "dtype", "out", "keepdims", "initial", "where"}), + "prod": frozenset({"axis", "dtype", "out", "keepdims", "initial", "where"}), + "mean": frozenset({"axis", "dtype", "out", "keepdims", "where"}), + "std": frozenset({"axis", "dtype", "out", "keepdims", "where", "ddof", "correction"}), + "var": frozenset({"axis", "dtype", "out", "keepdims", "where", "ddof", "correction"}), + "min": frozenset({"axis", "out", "keepdims", "initial", "where"}), + "max": frozenset({"axis", "out", "keepdims", "initial", "where"}), + "any": frozenset({"axis", "out", "keepdims", "where"}), + "all": frozenset({"axis", "out", "keepdims", "where"}), + "argmin": frozenset({"axis", "out", "keepdims"}), + "argmax": frozenset({"axis", "out", "keepdims"}), + "count_nonzero": frozenset({"axis", "keepdims"}), + "cumsum": frozenset({"axis", "dtype", "out"}), + "cumprod": frozenset({"axis", "dtype", "out"}), + "cumulative_sum": frozenset({"axis", "dtype", "out", "include_initial"}), + "cumulative_prod": frozenset({"axis", "dtype", "out", "include_initial"}), +} +_CAST_KEYWORDS = frozenset({"dtype", "order", "casting", "copy", "subok"}) +_UNKNOWN_ARGUMENT = object() + +_NUMPY_REDUCTION_POSITIONAL = { + "sum": ("axis", "dtype", "out", "keepdims"), + "prod": ("axis", "dtype", "out", "keepdims"), + "mean": ("axis", "dtype", "out", "keepdims"), + "std": ("axis", "dtype", "out", "ddof", "keepdims"), + "var": ("axis", "dtype", "out", "ddof", "keepdims"), + "min": ("axis", "out", "keepdims"), + "max": ("axis", "out", "keepdims"), + "any": ("axis", "out", "keepdims"), + "all": ("axis", "out", "keepdims"), + "argmin": ("axis", "out"), + "argmax": ("axis", "out"), + "cumsum": ("axis", "dtype", "out"), + "cumprod": ("axis", "dtype", "out"), + "cumulative_sum": (), + "cumulative_prod": (), +} +_BLOSC_REDUCTION_POSITIONAL = { + "sum": ("axis", "dtype", "keepdims"), + "prod": ("axis", "dtype", "keepdims"), + "mean": ("axis", "dtype", "keepdims"), + "std": ("axis", "dtype", "ddof", "keepdims"), + "var": ("axis", "dtype", "ddof", "keepdims"), + "min": ("axis", "keepdims"), + "max": ("axis", "keepdims"), + "any": ("axis", "keepdims"), + "all": ("axis", "keepdims"), + "argmin": ("axis", "keepdims"), + "argmax": ("axis", "keepdims"), + "cumulative_sum": ("axis", "dtype", "include_initial"), + "cumulative_prod": ("axis", "dtype", "include_initial"), +} +_CUMULATIVE_OPERATIONS = frozenset({"cumsum", "cumprod", "cumulative_sum", "cumulative_prod"}) + + +def _reduction_backend(name, receiver, *, method, prefer_blosc): + import blosc2 + + if name not in _NUMPY_REDUCTION_POSITIONAL: + return None + if not method: + if not prefer_blosc or name in {"cumsum", "cumprod"}: + return "numpy" + return ( + "blosc_numpy_function" + if type(receiver) is np.ndarray or type(receiver) in _NP_SCALARS + else "blosc_function" + ) + if type(receiver) is np.ndarray or type(receiver) in _NP_SCALARS: + return "numpy" + if type(receiver) is blosc2.LazyExpr: + return "blosc_lazy" + if isinstance(receiver, blosc2.Operand): + return "blosc_array" + # Column methods have their own table-specific API, not Operand's layout. + return None + + +def _qualified_reduction(name, prefer_blosc): + if name.startswith("numpy:"): + return name.split(":", 1)[1], False + if name.startswith("blosc2:"): + return name.split(":", 1)[1], True + return name, prefer_blosc + + +def _bind_reduction(name, positional, keywords, backend, *, literal=False): + """Bind only reviewed layouts; do not reflect arbitrary callable signatures.""" + if backend is None: + return None + layout, allowed = _reduction_layout(name, backend) + if len(positional) - 1 > len(layout) or not set(keywords) <= allowed: + _reject(f"unsupported {backend} signature for {name!r}") + bound = dict(keywords) + for key, value in zip(layout, positional[1:], strict=False): + if key in bound: + _reject(f"duplicate {key!r} argument for {name!r}") + bound[key] = value + for key, value in bound.items(): + _validate_argument(name, key, _literal_argument(value) if literal else value) + axis = bound.get("axis", _UNKNOWN_ARGUMENT) + if not literal and axis is not _UNKNOWN_ARGUMENT and axis is not None: + _reduction_axes(getattr(positional[0], "shape", ()), axis) + return bound + + +def _reduction_layout(name, backend): + allowed = _REDUCTION_KEYWORDS[name] + if backend == "numpy": + return _NUMPY_REDUCTION_POSITIONAL[name], allowed + if name not in _BLOSC_REDUCTION_POSITIONAL: + _reject(f"no approved {backend} method for {name!r}") + layout = _BLOSC_REDUCTION_POSITIONAL[name] + if name in _CUMULATIVE_OPERATIONS: + allowed -= {"out"} + if backend == "blosc_lazy": + layout = ("axis", "include_initial") + return layout, allowed + if backend != "blosc_numpy_function": + allowed -= {"initial", "correction"} + if name in {"any", "all"}: + allowed -= {"where"} + if backend == "blosc_lazy" and name in {"std", "var"}: + layout = ("axis", "dtype", "keepdims", "ddof") + if backend in {"blosc_function", "blosc_numpy_function", "blosc_lazy"} and "where" in allowed: + layout += ("where",) + return layout, allowed + + +def _reduction_axes(shape, axis): + rank = len(shape) + if not rank and axis is not None: + # NumPy's scalar-axis exceptions differ between operations; leave those + # to the selected implementation rather than inventing new semantics. + return None + axes = tuple(range(rank)) if axis is None else axis if type(axis) is tuple else (axis,) + if any(not -rank <= value < rank for value in axes): + raise ValueError(f"axis {axis!r} is out of bounds for an array of dimension {rank}") + normalized = {int(value) % rank for value in axes} + if len(normalized) != len(axes): + raise ValueError("duplicate reduction axes after normalization") + return normalized + + +def _resolved_metadata_argument(node, operands): + value = _literal_argument(node) + if value is _UNKNOWN_ARGUMENT and node[0] == "name": + value = operands.get(node[1], _UNKNOWN_ARGUMENT) + return value + + +def _root_reduction_metadata(name, receiver, bound, operands, backend): + """Data-free shape rules and a narrow, shared dtype-rule subset.""" + if not hasattr(receiver, "dtype") or not hasattr(receiver, "shape"): + return None, None + arguments = {key: _resolved_metadata_argument(value, operands) for key, value in bound.items()} + for key, value in arguments.items(): + _validate_argument(name, key, value) + input_shape = tuple(getattr(receiver, "shape", ())) + return _reduced_shape(name, input_shape, arguments), _root_reduction_dtype( + name, receiver, arguments, backend + ) + + +def _reduced_shape(name, input_shape, arguments): + if name in _CUMULATIVE_OPERATIONS: + return _cumulative_shape(name, input_shape, arguments) + axis, keepdims = arguments.get("axis"), arguments.get("keepdims", False) + shape = None + if axis is not _UNKNOWN_ARGUMENT and keepdims is not _UNKNOWN_ARGUMENT: + normalized = _reduction_axes(input_shape, axis) + if normalized is not None: + shape = ( + tuple(1 if index in normalized else size for index, size in enumerate(input_shape)) + if keepdims + else tuple(size for index, size in enumerate(input_shape) if index not in normalized) + ) + return shape + + +def _cumulative_shape(name, shape, arguments): + axis = arguments.get("axis") + include_initial = arguments.get("include_initial", False) + if axis is _UNKNOWN_ARGUMENT or include_initial is _UNKNOWN_ARGUMENT: + return None + if name in {"cumsum", "cumprod"} and axis is None: + return (math.prod(shape),) + if axis is None: + if len(shape) != 1: + raise ValueError(f"axis must be specified for {name} of non-1D array") + axis = 0 + normalized = _reduction_axes(shape, axis) + if normalized is None: + return None + return tuple( + size + int(include_initial) if index in normalized else size for index, size in enumerate(shape) + ) + + +def _graph_shape(node, operands, prefer_blosc): + """Data-free shape propagation; None means the rule is not reviewed yet.""" + kind, *args = node + if kind == "name": + value = operands[args[0]] + return tuple(value.shape) if hasattr(value, "shape") else () if np.isscalar(value) else None + if kind in {"literal", "dtype"}: + return () + if kind == "unary": + return () if args[0] is ast.Not else _graph_shape(args[1], operands, prefer_blosc) + if kind in {"binary", "compare"}: + if args[0] is ast.MatMult: + return None + shapes = [_graph_shape(item, operands, prefer_blosc) for item in args[1:]] + return None if any(shape is None for shape in shapes) else np.broadcast_shapes(*shapes) + if kind == "index": + shape = _graph_shape(args[0], operands, prefer_blosc) + index = _metadata_index(args[1], operands) + if shape is None or index is _UNKNOWN_ARGUMENT: + return None + import ndindex + + return ndindex.ndindex(index).newshape(shape) + if kind in {"call", "method"}: + return _graph_call_shape(node, operands, prefer_blosc) + return None + + +def _metadata_index(node, operands): + if node[0] == "slice": + values = [_resolved_metadata_argument(item, operands) for item in node[1:]] + if any(value is _UNKNOWN_ARGUMENT for value in values): + return _UNKNOWN_ARGUMENT + return slice(*values) + if node[0] == "sequence": + values = tuple(_metadata_index(item, operands) for item in node[1]) + return _UNKNOWN_ARGUMENT if any(value is _UNKNOWN_ARGUMENT for value in values) else values + value = _resolved_metadata_argument(node, operands) + # Boolean/fancy indexing is data-dependent. Do not read index arrays here. + return value if value is None or value is Ellipsis or _axis_integer(value) else _UNKNOWN_ARGUMENT + + +_UNARY_DTYPE_RULES = frozenset( + { + "abs", + "sqrt", + "sin", + "cos", + "exp", + "log", + "square", + "negative", + "positive", + "isfinite", + "isnan", + "isinf", + "logical_not", + } +) + +_BINARY_DTYPE_RULES = { + ast.Add: np.add, + ast.Sub: np.subtract, + ast.Mult: np.multiply, + ast.Div: np.true_divide, + ast.FloorDiv: np.floor_divide, + ast.Mod: np.remainder, + ast.Pow: np.power, + ast.BitAnd: np.bitwise_and, + ast.BitOr: np.bitwise_or, + ast.BitXor: np.bitwise_xor, + ast.LShift: np.left_shift, + ast.RShift: np.right_shift, + ast.Eq: np.equal, + ast.NotEq: np.not_equal, + ast.Lt: np.less, + ast.LtE: np.less_equal, + ast.Gt: np.greater, + ast.GtE: np.greater_equal, +} + + +def _numpy_value_graph(node, operands): + """Only trees whose reviewed operations retain NumPy receiver semantics.""" + kind, *args = node + if kind == "name": + value = operands[args[0]] + return ( + type(value) is np.ndarray + or type(value) in _NP_SCALARS + or type(value) in (int, float, complex, bool) + ) + if kind == "literal": + return args[0] in (int, float, complex, bool) + if kind in {"binary", "compare"}: + return args[0] in _BINARY_DTYPE_RULES and all( + _numpy_value_graph(item, operands) for item in args[1:] + ) + if kind == "index": + return ( + _numpy_value_graph(args[0], operands) + and _metadata_index(args[1], operands) is not _UNKNOWN_ARGUMENT + ) + if kind == "method" and args[0] == "astype": + return _numpy_value_graph(args[1][0], operands) + return False + + +def _numpy_binary_dtype(node, operands, prefer_blosc): + if not _numpy_value_graph(node, operands): + return None + if _NUMPY_VALUE_PROMOTION and any(_graph_shape(item, operands, prefer_blosc) == () for item in node[2:]): + # NumPy 1.x promotion can depend on scalar/0-D values, not just their + # declared dtype. Preserve backend inference instead of applying NEP 50. + return None + inputs = [] + values = [] + for item in node[2:]: + value = _resolved_metadata_argument(item, operands) + dtype = ( + type(value) + if type(value) in (int, float, complex) + else _graph_dtype(item, operands, prefer_blosc) + ) + if dtype is None: + return None + inputs.append(dtype) + values.append(value) + if all(type(dtype) is type for dtype in inputs): + return None # Preserve Python scalar evaluation, not ufunc scalar semantics. + resolved = _BINARY_DTYPE_RULES[node[1]].resolve_dtypes((*inputs, None)) + for value, dtype in zip(values, resolved[:2], strict=True): + if type(value) is int and dtype.kind in "iu": + limits = np.iinfo(dtype) + if not limits.min <= value <= limits.max: + raise OverflowError(f"Python integer {value} out of bounds for {dtype}") + elif type(value) in (float, complex) and dtype.kind in "fc": + # Existing warning/fallback behavior for scalar overflow is not yet + # specified independently; do not replace it with silent promotion. + limit = np.finfo(dtype).max.item() + components = (value.real, value.imag) if type(value) is complex else (value,) + if any(np.isfinite(component) and abs(component) > limit for component in components): + return None + return resolved[-1] + + +def _bind_numpy_cast(positional, keywords, *, literal=False): + layout = ("dtype", "order", "casting", "subok", "copy") + if len(positional) - 1 > len(layout) or not set(keywords) <= _CAST_KEYWORDS: + _reject("unsupported NumPy astype signature") + bound = dict(keywords) + for key, value in zip(layout, positional[1:], strict=False): + if key in bound: + _reject(f"duplicate {key!r} argument for astype") + bound[key] = value + if "dtype" not in bound: + _reject("astype requires a dtype argument") + for key, value in bound.items(): + _validate_argument("astype", key, _literal_argument(value) if literal else value) + return bound + + +def _numpy_cast_dtype(node, operands, prefer_blosc): + _, _, positional, keywords = node + if not _numpy_value_graph(positional[0], operands): + return None + bound = _bind_numpy_cast(positional, dict(keywords), literal=True) + arguments = {key: _resolved_metadata_argument(value, operands) for key, value in bound.items()} + for key, value in arguments.items(): + _validate_argument("astype", key, value) + requested, casting = arguments["dtype"], arguments.get("casting", "unsafe") + source = _graph_dtype(positional[0], operands, prefer_blosc) + if source is None or requested is _UNKNOWN_ARGUMENT or casting is _UNKNOWN_ARGUMENT: + return None + target = np.dtype(requested) + if target.subdtype is not None or target.kind not in "biufc": + # Flexible string widths and structured/subarray casts need their own + # output rules; a dtype descriptor alone does not describe the result. + return None + if not np.can_cast(source, target, casting=casting): + raise TypeError(f"Cannot cast array data from {source} to {target} according to {casting!r}") + return target + + +@dataclass(frozen=True) +class _ArrayMetadata: + shape: tuple + dtype: np.dtype + + +def _graph_reduction_metadata(kind, name, positional, keywords, operands, prefer_blosc): + receiver_node = positional[0] + if receiver_node[0] == "name": + receiver = operands[receiver_node[1]] + backend = _reduction_backend(name, receiver, method=kind == "method", prefer_blosc=prefer_blosc) + elif _numpy_value_graph(receiver_node, operands): + shape = _graph_shape(receiver_node, operands, prefer_blosc) + dtype = _graph_dtype(receiver_node, operands, prefer_blosc) + if shape is None or dtype is None: + return None + receiver = _ArrayMetadata(shape, dtype) + backend = ( + "numpy" + if kind == "method" or not prefer_blosc or name in {"cumsum", "cumprod"} + else "blosc_numpy_function" + ) + else: + return None + bound = _bind_reduction(name, positional, dict(keywords), backend, literal=True) + return None if bound is None else _root_reduction_metadata(name, receiver, bound, operands, backend) + + +def _graph_dtype(node, operands, prefer_blosc): + """Resolve a narrow numerical subset without computing synthetic values.""" + kind, *args = node + if kind == "name": + value = operands[args[0]] + if not hasattr(value, "dtype"): + return None + dtype = np.dtype(value.dtype) + return dtype if dtype.kind in "biufc" else None + if kind == "index" and _metadata_index(args[1], operands) is not _UNKNOWN_ARGUMENT: + return _graph_dtype(args[0], operands, prefer_blosc) + if kind in {"binary", "compare"} and args[0] in _BINARY_DTYPE_RULES: + return _numpy_binary_dtype(node, operands, prefer_blosc) + if kind == "method" and args[0] == "astype": + return _numpy_cast_dtype(node, operands, prefer_blosc) + if kind not in {"call", "method"}: + return None + name, positional, keywords = args + name, prefer_blosc = _qualified_reduction(name, prefer_blosc) + if name in _NUMPY_REDUCTION_POSITIONAL: + metadata = _graph_reduction_metadata(kind, name, positional, keywords, operands, prefer_blosc) + if metadata is not None: + return metadata[1] + if kind == "call" and name in _UNARY_DTYPE_RULES and len(positional) == 1 and not keywords: + dtype = _graph_dtype(positional[0], operands, prefer_blosc) + if dtype is not None: + return getattr(np, name).resolve_dtypes((dtype, None))[-1] + return None + + +def _graph_call_shape(node, operands, prefer_blosc): + kind, name, positional, keywords = node + name, prefer_blosc = _qualified_reduction(name, prefer_blosc) + if ( + kind == "call" + and name == "asarray" + and len(positional) in (1, 2) + and set(dict(keywords)) <= {"dtype"} + ): + return _graph_shape(positional[0], operands, prefer_blosc) + if kind == "method" and name == "astype" and _numpy_value_graph(positional[0], operands): + bound = _bind_numpy_cast(positional, dict(keywords), literal=True) + requested = _resolved_metadata_argument(bound["dtype"], operands) + if requested is _UNKNOWN_ARGUMENT or np.dtype(requested).subdtype is not None: + return None + return _graph_shape(positional[0], operands, prefer_blosc) + if name in _NUMPY_REDUCTION_POSITIONAL: + metadata = _graph_reduction_metadata(kind, name, positional, keywords, operands, prefer_blosc) + if metadata is not None: + return metadata[0] + if kind == "call" and name in _NUMPY_REDUCTION_POSITIONAL: + shape = _graph_shape(positional[0], operands, prefer_blosc) + if shape is None: + return None + backend = "blosc_function" if prefer_blosc and name not in {"cumsum", "cumprod"} else "numpy" + bound = _bind_reduction(name, positional, dict(keywords), backend, literal=True) + arguments = {key: _resolved_metadata_argument(value, operands) for key, value in bound.items()} + for key, value in arguments.items(): + _validate_argument(name, key, value) + return _reduced_shape(name, shape, arguments) + if kind == "call" and name in _ELEMENTWISE - {"broadcast_to", "where"}: + if (name == "clip" and keywords) or any(key in {"out", "where"} for key, _ in keywords): + return None + # The optional decimals argument of round is metadata, not an array. + values = positional[:1] if name == "round" else positional + shapes = [_graph_shape(item, operands, prefer_blosc) for item in values] + return None if any(shape is None for shape in shapes) else np.broadcast_shapes(*shapes) + return None + + +def _statistical_reduction_dtype(input_dtype, requested, numpy_receiver): + # Complex variance and integer accumulator overrides still use the + # existing inference path: NumPy and Blosc2 do not share their rules. + if input_dtype.kind not in "biuf": + return None + if requested is not None: + return np.dtype(requested) if np.dtype(requested).kind == "f" else None + if numpy_receiver: + return np.dtype("float64") if input_dtype.kind in "biu" else input_dtype + from blosc2.lazyexpr import ReduceOp, infer_reduction_dtype + + accumulation = np.dtype(infer_reduction_dtype(input_dtype, ReduceOp.SUM)) + return np.dtype("float64") if accumulation.kind in "biu" else accumulation + + +def _root_reduction_dtype(name, receiver, arguments, backend): + dtype = None + requested, output = arguments.get("dtype"), arguments.get("out") + if output is _UNKNOWN_ARGUMENT or requested is _UNKNOWN_ARGUMENT: + return None + input_dtype = np.dtype(getattr(receiver, "dtype", type(receiver))) + if input_dtype.kind not in "biufc": + return None + numpy_receiver = backend in {"numpy", "blosc_numpy_function"} or ( + type(receiver) is np.ndarray or type(receiver) in _NP_SCALARS + ) + if ( + _BLOSC_PLATFORM_ACCUMULATOR_FALLBACK + and not numpy_receiver + and requested is None + and output is None + and name in {"sum", "prod"} | _CUMULATIVE_OPERATIONS + and input_dtype.kind in "biu" + and input_dtype.itemsize < 8 + ): + # Single-threaded WASM uses the existing NumPy reduction fallback, + # whose default integer accumulator width is platform-sized. + # Index reductions instead retain Blosc2's DEFAULT_INDEX contract. + return np.dtype(np.uintp if input_dtype.kind == "u" else np.intp) + if name in _CUMULATIVE_OPERATIONS and backend != "numpy" and requested is not None: + # The current Blosc2 cumulative implementation does not consistently + # apply dtype overrides. Preserve its inference rather than claiming + # the requested accumulator dtype is the output dtype. + return None + if output is not None: + dtype = np.dtype(output.dtype) + elif not numpy_receiver and input_dtype == np.dtype("float16") and requested is None: + # Half precision currently follows fallback-specific promotion paths, + # not infer_reduction_dtype's generic promotion. Keep existing inference. + return None + elif name in {"mean", "std", "var"}: + dtype = _statistical_reduction_dtype(input_dtype, requested, numpy_receiver) + else: + if requested is not None: + dtype = np.dtype(requested) + else: + if not numpy_receiver: + from blosc2.lazyexpr import ReduceOp, infer_reduction_dtype + + if name not in {"min", "max"} or input_dtype.kind != "b": + dtype = np.dtype(infer_reduction_dtype(input_dtype, getattr(ReduceOp, name.upper()))) + elif name in {"any", "all"}: + dtype = np.dtype(bool) + elif name in {"argmin", "argmax"}: + dtype = np.dtype(np.intp) + elif name in {"sum", "prod"} | _CUMULATIVE_OPERATIONS and input_dtype.kind in "biu": + platform_dtype = np.dtype(np.uintp if input_dtype.kind == "u" else np.intp) + dtype = ( + platform_dtype + if input_dtype.itemsize < platform_dtype.itemsize or input_dtype.kind == "b" + else input_dtype + ) + else: + dtype = input_dtype + return dtype + + +def _literal_argument(node): + """Read constants only, without evaluating calls or folding arithmetic.""" + kind, *args = node + if kind == "literal": + return args[1] + if kind == "dtype": + return np.dtype(args[0]).type + if kind == "sequence": + items = tuple(_literal_argument(item) for item in args[0]) + return _UNKNOWN_ARGUMENT if any(item is _UNKNOWN_ARGUMENT for item in items) else items + if kind == "unary" and args[0] in (ast.UAdd, ast.USub): + value = _literal_argument(args[1]) + if type(value) in (int, float, complex): + return _UNARY[args[0]](value) + return _UNKNOWN_ARGUMENT + + +def _axis_integer(item): + return type(item) is int or (type(item) in _NP_SCALARS and np.dtype(type(item)).kind in "iu") + + +def _validate_argument(name, key, value, node=None): + """Validate admitted values; never coerce arbitrary objects to metadata.""" + if value is _UNKNOWN_ARGUMENT: + return + valid = True + if key == "axis": + valid = value is None or _axis_integer(value) + if type(value) is tuple and name not in { + "argmin", + "argmax", + "cumsum", + "cumprod", + "cumulative_sum", + "cumulative_prod", + }: + valid = all(_axis_integer(item) for item in value) and len(set(value)) == len(value) + elif key in {"keepdims", "copy", "subok", "include_initial"}: + valid = type(value) in (bool, np.bool_) + elif key == "out": + import blosc2 + + valid = value is None or type(value) in (np.ndarray, blosc2.NDArray, blosc2.NDField) + elif key in {"ddof", "correction"}: + valid = type(value) in (int, float) or ( + type(value) in _NP_SCALARS and np.dtype(type(value)).kind in "iuf" + ) + elif key == "dtype": + if value is not None and type(value) not in (str, tuple, type, np.str_): + _reject(f"invalid {key!r} argument for {name!r}", node) + try: + valid = not np.dtype(value).hasobject + except (TypeError, ValueError): + valid = False + elif key == "casting": + valid = type(value) is str and value in {"no", "equiv", "safe", "same_kind", "unsafe"} + elif key == "order": + valid = type(value) is str and value in {"C", "F", "A", "K"} + if not valid: + _reject(f"invalid {key!r} argument for {name!r}", node) + + +def _check_call_contract(name, positional, keywords, node=None, *, literal=False): + if name not in _REDUCTION_KEYWORDS and name not in {"astype", "asarray"}: + return + if name == "astype" and len(positional) < 2 and "dtype" not in keywords: + _reject("astype requires a dtype argument", node) + for key, value in keywords.items(): + _validate_argument(name, key, _literal_argument(value) if literal else value, node) + # These common prefix positions agree across approved receivers. + positions = ((1, "dtype"),) if name in {"astype", "asarray"} else ((1, "axis"),) + if name in { + "sum", + "prod", + "mean", + "std", + "var", + "cumsum", + "cumprod", + }: + positions += ((2, "dtype"),) + for index, key in positions: + if len(positional) > index: + if key in keywords: + _reject(f"duplicate {key!r} argument for {name!r}", node) + value = positional[index] + _validate_argument(name, key, _literal_argument(value) if literal else value, node) + if "ddof" in keywords and "correction" in keywords: + _reject(f"cannot supply both ddof and correction for {name!r}", node) + + +def _check_signature(name, count, keywords, node): + if name in _ELEMENTWISE: + low, high = (2, 2) if name in _BINARY_CALLS else (1, 1) + if name == "where" or name == "clip": + low, high = 1, 3 + elif name == "round": + low, high = 1, 2 + allowed = {"out", "where", "casting", "dtype"} + if name in ("clip", "round", "broadcast_to"): + allowed |= {"min", "max", "a_min", "a_max", "decimals", "shape"} + elif name in _REDUCTIONS: + low, high = 1, 6 + allowed = _REDUCTION_KEYWORDS[name] + elif name == "astype": + low, high, allowed = 1, 6, _CAST_KEYWORDS + elif name in _DTYPES: + low, high, allowed = 0, 1, set() + elif name in ("len", "slice"): + low, high, allowed = (1, 1, set()) if name == "len" else (1, 3, set()) + else: + low, high, allowed = 1, 7, _KEYWORDS + if not low <= count <= high or not set(keywords) <= allowed: + _reject(f"invalid signature for {name!r}", node) + + +def _reject(message, node=None): + location = f"expression line {node.lineno}, column {node.col_offset + 1}" if node is not None else None + raise UnsafeDeserializationError( + message, + location=location, + hint="Use deserialize='full' when loading, or expression_evaluation('full') " + "when constructing, only if you trust the expression and its operands.", + ) + + +@dataclass(frozen=True) +class ExpressionGraph: + root: tuple + names: frozenset[str] + text: str + arithmetic: bool = field(default=False, compare=False) + + def infer_shape(self, operands, *, prefer_blosc=True): + """Propagate reviewed shape rules without fetching operand data.""" + validate_operands(operands) + return _graph_shape(self.root, operands, prefer_blosc) + + def infer_dtype(self, operands, *, prefer_blosc=True): + """Return a reviewed output dtype, or None to retain existing inference.""" + validate_operands(operands) + return _graph_dtype(self.root, operands, prefer_blosc) + + def bind_root_reduction(self, operands, *, prefer_blosc=True): + """Make root positional arguments explicit before dummy-array inference. + + Only direct named inputs are covered here. Nested-expression metadata and + table-specific receivers retain the existing inference path. + """ + if self.root[0] not in {"call", "method"}: + return None + kind, name, positional, keywords = self.root + name, prefer_blosc = _qualified_reduction(name, prefer_blosc) + if not positional or positional[0][0] != "name": + return None + receiver = operands.get(positional[0][1]) + backend = _reduction_backend(name, receiver, method=kind == "method", prefer_blosc=prefer_blosc) + bound = _bind_reduction(name, positional, dict(keywords), backend, literal=True) + if bound is None: + return None + shape, dtype = _root_reduction_metadata(name, receiver, bound, operands, backend) + if len(positional) == 1: + return None, shape, dtype + tree = ast.parse(self.text, mode="eval") + call = tree.body + # Associate immutable graph argument nodes with their original AST nodes. + arguments = ([call.func.value] if kind == "method" else []) + call.args + nodes = {keyword.arg: keyword.value for keyword in call.keywords} + positional_keys = [key for key in bound if key not in nodes] + nodes.update(zip(positional_keys, arguments[1:], strict=True)) + call.args = [] if kind == "method" else [call.args[0]] + call.keywords = [ast.keyword(arg=key, value=nodes[key]) for key in bound] + return ast.unparse(tree.body), shape, dtype + + def evaluate(self, operands, *, prefer_blosc=False): # noqa: C901 + validate_operands(operands) + missing = self.names - operands.keys() + if missing: + raise ValueError(f"Missing expression operands: {sorted(missing)}") + cache = {} + + def visit(node): # noqa: C901 + if node in cache: + return cache[node] + kind, *args = node + if kind == "literal": + result = args[1] + elif kind == "name": + result = operands[args[0]] + elif kind == "dtype": + result = np.dtype(args[0]).type + elif kind == "sequence": + result = tuple(visit(x) for x in args[0]) + elif kind == "binary": + result = _BINARY[args[0]](visit(args[1]), visit(args[2])) + elif kind == "unary": + result = _UNARY[args[0]](visit(args[1])) + elif kind == "boolean": + result = visit(args[1][0]) + for item in args[1][1:]: + if (args[0] is ast.And and not result) or (args[0] is ast.Or and result): + break + result = visit(item) + elif kind == "compare": + result = _COMPARE[args[0]](visit(args[1]), visit(args[2])) + elif kind == "slice": + result = slice(*(visit(x) for x in args)) + elif kind == "index": + result = visit(args[0])[visit(args[1])] + elif kind == "attribute": + value = visit(args[1]) + validate_operand(value) + result = getattr(value, args[0]) + elif kind in ("call", "method"): + name, positional, keywords = args + values = [visit(x) for x in positional] + kwargs = {key: visit(value) for key, value in keywords} + result = _dispatch(name, values, kwargs, prefer_blosc, method=kind == "method") + else: + raise AssertionError(kind) + validate_operand(result) + cache[node] = result + return result + + try: + return visit(self.root) + finally: + # The recursive closure references itself. Break that cycle and + # drop evaluation-local arrays immediately, including on failure, + # rather than retaining operands/results until cyclic GC runs. + cache.clear() + visit = None + + +@functools.lru_cache(maxsize=512) +def expression_syntax(text): + """Share read-only syntax and its traversal; transformations must copy before editing.""" + tree = ast.parse(text, mode="eval") + return tree, tuple(ast.walk(tree)) + + +def arithmetic_names(text): # noqa: C901 -- explicit arithmetic node admission + """Names of an expression whose graph is plain arithmetic, else ``None``. + + A conservative fast path for :func:`parse_expression` that shares its cached + syntax and skips graph lowering plus canonical unparsing. It reports names + only when every node is an arithmetic literal, name, binary/unary operation + or single comparison; everything else returns ``None`` so the caller retains + the full parser as the authority. + """ + try: + tree, _ = expression_syntax(text) + except (SyntaxError, RecursionError): + return None + names = set() + count = 0 + stack = [(tree.body, 0)] + while stack: + node, depth = stack.pop() + count += 1 + if depth > 64 or count > 4096: + return None + if isinstance(node, ast.Constant): + if type(node.value) not in (bool, int, float): + return None + elif isinstance(node, ast.Name): + if node.id in ("nan", "inf") or node.id in _DTYPES: + continue + if node.id in ("np", "numpy", "blosc2"): + return None + names.add(node.id) + elif isinstance(node, ast.BinOp): + if type(node.op) not in _BINARY or isinstance(node.op, ast.MatMult): + return None + stack.append((node.left, depth + 1)) + stack.append((node.right, depth + 1)) + elif isinstance(node, ast.UnaryOp): + if type(node.op) not in _UNARY or isinstance(node.op, ast.Not): + return None + stack.append((node.operand, depth + 1)) + elif isinstance(node, ast.Compare): + if len(node.ops) != 1 or type(node.ops[0]) not in _COMPARE: + return None + stack.append((node.left, depth + 1)) + stack.append((node.comparators[0], depth + 1)) + else: + return None + return tuple(sorted(names)) + + +@functools.lru_cache(maxsize=512) +def parse_expression(text): # noqa: C901 + """Compile a bounded expression to an immutable, explicitly registered graph.""" + if type(text) is not str or len(text) > 65536: + _reject("expression must be text of at most 65536 characters") + try: + tree, nodes = expression_syntax(text) + except (SyntaxError, RecursionError) as exc: + raise ValueError(f"Invalid numerical expression: {text!r}") from exc + if len(nodes) > 4096: + _reject("expression exceeds 4096 AST nodes") + names = set() + arithmetic = True + arithmetic_nodes = (ast.Constant, ast.Name, ast.BinOp, ast.UnaryOp, ast.Compare) + + def lower(node, depth=0): # noqa: C901 + nonlocal arithmetic + if depth > 64: + _reject("expression exceeds 64 levels", node) + if ( + not isinstance(node, arithmetic_nodes) + or (isinstance(node, ast.Constant) and type(node.value) not in (bool, int, float)) + or (isinstance(node, (ast.BinOp, ast.UnaryOp)) and isinstance(node.op, (ast.MatMult, ast.Not))) + ): + arithmetic = False + + def child(x): + return lower(x, depth + 1) + + if isinstance(node, ast.Constant): + if type(node.value) not in (int, float, complex, bool, str, bytes, type(None), type(Ellipsis)): + _reject("unsupported literal", node) + return ("literal", type(node.value), node.value) + if isinstance(node, ast.Name): + if node.id in ("nan", "inf"): + return ("literal", float, float(node.id)) + if node.id in _DTYPES: + return ("dtype", node.id) + if node.id in ("np", "numpy", "blosc2"): + _reject("unapproved symbol", node) + names.add(node.id) + return ("name", node.id) + if isinstance(node, ast.BinOp) and type(node.op) in _BINARY: + return ("binary", type(node.op), child(node.left), child(node.right)) + if isinstance(node, ast.UnaryOp) and type(node.op) in _UNARY: + return ("unary", type(node.op), child(node.operand)) + if isinstance(node, ast.BoolOp): + return ("boolean", type(node.op), tuple(child(x) for x in node.values)) + if isinstance(node, ast.Compare) and len(node.ops) == 1 and type(node.ops[0]) in _COMPARE: + return ("compare", type(node.ops[0]), child(node.left), child(node.comparators[0])) + if isinstance(node, ast.Tuple | ast.List): + return ("sequence", tuple(child(x) for x in node.elts)) + if isinstance(node, ast.Slice): + return ( + "slice", + *( + child(x) if x is not None else ("literal", type(None), None) + for x in (node.lower, node.upper, node.step) + ), + ) + if isinstance(node, ast.Subscript): + return ("index", child(node.value), child(node.slice)) + if isinstance(node, ast.Attribute): + if isinstance(node.value, ast.Name) and node.value.id in ("np", "numpy", "blosc2"): + if node.attr in _DTYPES: + return ("dtype", node.attr) + _reject(f"unapproved namespace attribute {node.attr!r}", node) + if node.attr in _ATTRIBUTES: + return ("attribute", node.attr, child(node.value)) + if isinstance(node, ast.Call): + method = False + namespace_name = None + positional = tuple(child(x) for x in node.args) + if isinstance(node.func, ast.Name): + name = node.func.id + elif isinstance(node.func, ast.Attribute): + name = node.func.attr + namespace = isinstance(node.func.value, ast.Name) and node.func.value.id in ( + "np", + "numpy", + "blosc2", + ) + if not namespace: + method = True + positional = (child(node.func.value), *positional) + else: + namespace_name = node.func.value.id + else: + _reject("unapproved callable", node) + if name not in (_METHODS if method else _CALLS): + _reject(f"unapproved numerical operation {name!r}", node) + if any(kw.arg not in (_KEYWORDS | _CAST_KEYWORDS) for kw in node.keywords): + _reject(f"unapproved keyword for {name!r}", node) + if len({kw.arg for kw in node.keywords}) != len(node.keywords): + _reject("duplicate keyword", node) + if not (method and name == "slice"): + _check_signature(name, len(positional), [kw.arg for kw in node.keywords], node) + keywords = {kw.arg: child(kw.value) for kw in node.keywords} + _check_call_contract(name, positional, keywords, node, literal=True) + if namespace_name is not None and name in _NUMPY_REDUCTION_POSITIONAL: + prefix = "blosc2" if namespace_name == "blosc2" else "numpy" + name = f"{prefix}:{name}" + return ( + "method" if method else "call", + name, + positional, + tuple(keywords.items()), + ) + return _reject(f"unsupported syntax {type(node).__name__}", node) + + root = lower(tree.body) + return ExpressionGraph(root, frozenset(names), ast.unparse(tree.body), arithmetic) + + +def validate_operand(value): # noqa: C901 + """Admit concrete trusted operand types before reading their metadata/hooks.""" + import blosc2 + + metaclass = type(type(value)) + if metaclass is not type and metaclass is not abc.ABCMeta: + _reject("custom operand metaclass") + if type(value) in (int, float, complex, bool, str, bytes, type(None), slice, type(Ellipsis)): + return + if type(value) is type and value in _DTYPE_TYPES: + return + if type(value) in (tuple, list): + active = _active_operands.get() + if id(value) in active or len(active) >= 64: + _reject("cyclic or excessively deep expression operands") + token = _active_operands.set(active | {id(value)}) + try: + for item in value: + validate_operand(item) + finally: + _active_operands.reset(token) + return + if type(value) is np.ndarray or type(value) in _NP_SCALARS: + if _validated_dtype(value.dtype).hasobject: + _reject("object-dtype expression operand") + return + trusted = { + blosc2.NDArray, + blosc2.LazyExpr, + blosc2.NDField, + blosc2.C2Array, + blosc2.RemoteArray, + blosc2.Proxy, + blosc2.SimpleProxy, + blosc2.LazyUDF, + } + from blosc2.ctable import Column + from blosc2.ctable_storage import _AllValidRows, _RemoteHDF5Field + from blosc2.portable_lazy import PortableLazyArray + from blosc2.proxy import ProxyNDField + from blosc2.remote_parquet import _ParquetColumn + + trusted.add(Column) + trusted.add(ProxyNDField) + trusted.update({_AllValidRows, _RemoteHDF5Field, _ParquetColumn, PortableLazyArray}) + if type(value) not in trusted: + _reject(f"unapproved operand type {type(value).__name__!r}") + active = _active_operands.get() + if id(value) in active or len(active) >= 64: + _reject("cyclic or excessively deep expression operands") + token = _active_operands.set(active | {id(value)}) + try: + if type(value) is blosc2.LazyUDF: + if getattr(value, "_legacy_source_recipe", False): + _reject("legacy UDF expression dependency") + # Caller-authored UDFs are explicit capabilities, not functions + # constructible by saved graph text. Still check their input closure. + validate_operands(value.inputs_dict) + if type(value) is blosc2.LazyExpr: + parse_expression(value.expression) + validate_operands(value.operands) + validate_operands(getattr(value, "_where_args", {})) + if type(value) is blosc2.SimpleProxy: + validate_operand(value._src) + _synchronize_simple_proxy(value) + elif type(value) is blosc2.Proxy: + # Proxy itself is not a capability boundary: its source can be a + # caller-defined Python protocol object. + validate_operand(value.src) + _validate_proxy_cache(value) + elif type(value) is ProxyNDField: + validate_operand(value.proxy) + fields = value.proxy.dtype.fields + if fields is None or type(value.field) is not str or value.field not in fields: + raise ValueError("ProxyNDField no longer refers to an existing structured field") + value._dtype, value._shape = fields[value.field][0], tuple(value.proxy.shape) + elif type(value) is blosc2.NDField: + validate_operand(value.ndarr) + _synchronize_ndfield(value) + elif type(value) is _RemoteHDF5Field: + validate_operand(value.records) + _synchronize_remote_field(value) + elif type(value) is _ParquetColumn: + _validate_parquet_column(value) + elif type(value) is blosc2.RemoteArray: + _validate_remote_array(value) + elif type(value) is PortableLazyArray: + _validate_portable_array(value) + elif type(value) is Column: + table = value._table_ref + if type(table) is blosc2.RemoteCTable: + storage = value._remote_storage_ref + _validate_parquet_storage(storage) + if storage is not table._remote_read_storage(): + raise ValueError("Remote column storage no longer matches its table") + elif type(table) is not blosc2.CTable: + _reject("unapproved column owner") + if type(value._col_name) is not str: + _reject("unapproved column name") + _validate_operand_mapping(table._computed_cols) + _validate_column_mapping(table._cols, table) + validate_operand(table._valid_rows) + validate_operand(value._mask) + validate_operand(getattr(table, "_cached_live_positions", None)) + recipe = table._computed_cols.get(value._col_name) + if recipe is not None and (type(recipe) is not dict or type(recipe.get("kind")) is not str): + _reject("unapproved computed-column recipe mapping or kind") + if recipe is None: + validate_operand(table._cols[value._col_name]) + elif recipe.get("kind") == "dsl": + _reject("legacy table-kernel expression dependency") + else: + if recipe.get("kind") not in {"expression", "portable"}: + _reject("unapproved computed-column recipe kind") + if recipe.get("kind") == "expression": + descriptor_graph = parse_expression(recipe["expression"]) + if type(recipe.get("lazy")) is not blosc2.LazyExpr: + _reject("unapproved cached computed-column expression") + cached = recipe["lazy"] + validate_operand(cached) + expected = {f"o{i}": table._cols[dep] for i, dep in enumerate(recipe["col_deps"])} + if ( + parse_expression(cached.expression).root != descriptor_graph.root + or cached.operands.keys() != expected.keys() + or any(cached.operands[name] is not source for name, source in expected.items()) + ): + raise ValueError( + "Computed-column recipe/cache mismatch; recreate the computed column" + ) + else: + _validate_portable_column(table, recipe) + for dependency in recipe["col_deps"]: + validate_operand(Column(table, dependency)) + if _validated_dtype(value.dtype).hasobject: + _reject("object-dtype expression operand") + finally: + _active_operands.reset(token) + + +def _validate_column_mapping(mapping, table, active=()): + import blosc2 + from blosc2.ctable import _LazyColumnDict + from blosc2.ctable_storage import ( + EmbedStoreTableStorage, + FileTableStorage, + InMemoryTableStorage, + RemoteTableStorage, + TreeStoreTableStorage, + ) + from blosc2.remote_parquet import ParquetTableStorage + + if type(mapping) is not _LazyColumnDict: + _validate_operand_mapping(mapping) + return + if id(mapping) in active or len(active) >= 64: + _reject("cyclic or excessively deep lazy column mappings") + if type(table) not in (blosc2.CTable, blosc2.RemoteCTable) or mapping._table is not table: + _reject("unapproved lazy column mapping owner") + if ( + type(mapping._storage) + not in { + EmbedStoreTableStorage, + FileTableStorage, + InMemoryTableStorage, + RemoteTableStorage, + TreeStoreTableStorage, + ParquetTableStorage, + } + or mapping._storage is not table._storage + ): + _reject("unapproved lazy column mapping storage") + if type(mapping._available) is not set or any(type(name) is not str for name in mapping._available): + _reject("unapproved lazy column mapping names") + source = mapping._source_cols + if source is not None: + owner = source._table if type(source) is _LazyColumnDict else table + _validate_column_mapping(source, owner, (*active, id(mapping))) + + +def _validated_dtype(value): + if value is None or type(value) is str: + value = np.dtype(value) + elif type(value) is type: + if value not in _NP_SCALARS and value not in (int, float, complex, bool, str, bytes): + from blosc2 import schema + + if not any(value is getattr(schema, name, None) for name in _DTYPES): + _reject("unapproved dtype type") + value = np.dtype(value) + _validate_dtype_metadata(value) + return value + + +def _validate_dtype_metadata(dtype, depth=0): + if type(dtype) not in _DTYPE_METADATA_TYPES or depth >= 64: + _reject("unapproved or excessively deep dtype metadata") + if dtype.fields is not None: + if any(type(name) is not str for name in dtype.fields): + _reject("unapproved structured dtype field key") + for field in dtype.fields.values(): + _validate_dtype_metadata(field[0], depth + 1) + if dtype.subdtype is not None: + _validate_dtype_metadata(dtype.subdtype[0], depth + 1) + + +def _validate_portable_column(table, recipe): + from blosc2.ctable import Column + + cached = recipe.get("kernel") + if cached is not None: + _validate_portable_kernel(cached) + if type(recipe["artifact"]) not in (str, bytes): + _reject("unapproved portable recipe artifact") + bindings = recipe["bindings"] + if type(bindings) is not dict or any( + type(k) is not str or type(v) is not str for k, v in bindings.items() + ): + _reject("unapproved portable column bindings") + dependencies = recipe["col_deps"] + row_shape = recipe.get("row_shape", (1,)) + if ( + type(dependencies) not in (list, tuple) + or any(type(dep) is not str for dep in dependencies) + or type(row_shape) not in (list, tuple) + or any(type(n) is not int for n in row_shape) + or type(recipe.get("row_domain", "independent")) is not str + ): + _reject("unapproved portable column metadata") + dtype = recipe["dtype"] + if type(dtype) is not str and type(dtype) not in {type(np.dtype(name)) for name in _DTYPES}: + _reject("unapproved portable column dtype") + for dependency in dict.fromkeys((*dependencies, *bindings.values())): + validate_operand(Column(table, dependency)) + if cached is None: + table._validate_portable_table_metadata(recipe) + return + artifact = recipe["artifact"] + if cached._artifact != (artifact.encode("utf-8") if type(artifact) is str else artifact): + raise ValueError("Portable-column recipe/cache mismatch; recreate the computed column") + if recipe.get("row_domain", "independent") != "independent": + raise ValueError("Only independent-row portable table groups are implemented") + # The admitted cached handle already owns this exact validated artifact. + # Recheck current bindings without reparsing/recompiling it on every slice. + descriptor = table._portable_table_descriptor(cached, bindings) + if ( + descriptor["dtype"] != np.dtype(dtype) + or descriptor["col_deps"] != list(dependencies) + or descriptor["row_shape"] != tuple(row_shape) + ): + raise ValueError("Portable table metadata disagrees with native signature/bindings") + + +def _validate_portable_array(value): + _validate_portable_kernel(value.kernel) + if type(value.inputs) is not dict or any(type(name) is not str for name in value.inputs): + _reject("unapproved portable input mapping") + validate_operands(value.inputs) + domain, partitions = value._domain, value._partitions + for extents in (domain, partitions, value._shape, value._grid): + if type(extents) is not tuple or any(type(n) is not int for n in extents): + _reject("unapproved portable domain metadata") + if ( + any(not 0 <= n <= np.iinfo(np.int64).max for n in domain) + or len(partitions) != len(domain) + or any(n <= 0 for n in partitions) + or math.prod(partitions) > 2147483647 + or value.kernel.context_ndim not in (0, len(domain)) + ): + raise ValueError("Portable domain/partition contract changed; construct a new array") + grid = tuple((n + p - 1) // p for n, p in zip(domain, partitions, strict=True)) + shape = grid if value.kernel.result_cardinality == "block_scalar" else domain + if value._grid != grid or value._shape != shape: + raise ValueError("Portable cached geometry disagrees with domain/partitions; construct a new array") + if value.inputs.keys() != value.kernel.input_dtypes.keys(): + raise ValueError("Portable input names disagree with native signature") + for name, source in value.inputs.items(): + if ( + np.broadcast_shapes(tuple(source.shape), domain) != domain + or np.dtype(source.dtype).newbyteorder("=") != value.kernel.input_dtypes[name] + ): + raise ValueError("Portable input metadata changed; construct a new array") + + +def _same_native_metadata(actual, expected): + """Compare native-owned metadata without consulting foreign equality hooks.""" + if type(actual) is not type(expected): + return False + if type(expected) is dict: + if any(type(key) is not str for key in actual) or actual.keys() != expected.keys(): + return False + return all(_same_native_metadata(actual[key], value) for key, value in expected.items()) + if type(expected) in (tuple, list): + return len(actual) == len(expected) and all( + _same_native_metadata(a, b) for a, b in zip(actual, expected, strict=True) + ) + return actual == expected + + +def _validate_portable_kernel(value): + import blosc2 + from blosc2 import blosc2_ext + + if type(value) is not blosc2.PortableKernel: + _reject("unapproved portable kernel dependency") + if type(value._handle) is not blosc2_ext.PortableArtifactHandle: + _reject("unapproved portable native handle") + if ( + value._handle is not value._expression_handle + or type(value._artifact) is not bytes + or type(value._expression_artifact) is not bytes + or value._artifact != value._expression_artifact + ): + raise ValueError("Portable kernel provenance changed; construct a new kernel") + expected = value._handle.info() + if getattr(blosc2_ext, "portable_descriptor_available", lambda: False)(): + expected.update(value._handle.descriptor_info()) + if not _same_native_metadata(value._info, expected): + _reject("portable kernel metadata disagrees with native handle") + + +def _validate_remote_array(value): + """Check the concrete transport/cache closure without opening or fetching it.""" + from blosc2.remote_store import RemoteDiscovery + + owner = value._store_owner + if owner is not None and type(owner) is not RemoteDiscovery: + _reject("unapproved RemoteArray store owner") + operation_lock = value._operation_lock + owner_lock = owner.lock if owner is not None else None + if type(operation_lock) is not _thread.RLock or ( + owner_lock is not None and type(owner_lock) is not _thread.RLock + ): + _reject("unapproved RemoteArray operation lock") + with owner_lock if owner_lock is not None else contextlib.nullcontext(), operation_lock: + if value._store_owner is not owner or value._operation_lock is not operation_lock: + raise ValueError("RemoteArray ownership changed during admission; retrieve a new handle") + _validate_remote_array_locked(value) + + +def _validate_remote_array_locked(value): + import blosc2 + from blosc2.c2array import C2NDSource + from blosc2.remote_store import _Caterva2ArraySource + + sources = { + blosc2.C2Array, + C2NDSource, + _Caterva2ArraySource, + blosc2.FsspecNDSource, + blosc2.ZarrNDSource, + blosc2.HDF5NDSource, + blosc2.B2ZNDSource, + } + if type(value.src) not in sources: + _reject("unapproved RemoteArray transport source") + if value.src is not value._expression_source: + raise ValueError("RemoteArray source was rebound; use refresh() or construct a new array") + value._check_open() + if value._geometry(value.src) != value._expected_geometry: + raise ValueError("RemoteArray source geometry changed; use refresh() or retrieve a new array") + if value._proxy is not None: + if type(value._proxy) is not blosc2.Proxy or value._proxy.src is not value.src: + _reject("unapproved RemoteArray cache proxy") + _validate_proxy_cache(value._proxy) + for cache in (value._carrier, value._runtime_cache): + if cache is not None: + if type(cache) is not blosc2.NDArray: + _reject("unapproved RemoteArray cache carrier") + validate_operand(cache) + + +def _validate_parquet_column(value): + from blosc2.schema import NDArraySpec + from blosc2.schema_compiler import CompiledColumn + + storage = value.storage + with _parquet_storage_scope(storage): + if storage is not value._source_storage: + raise ValueError("Parquet column storage was rebound; open a new column") + if type(value.name) is not str or value.name not in storage.schema.columns_by_name: + raise ValueError("Parquet column no longer exists in its schema") + column = storage.schema.columns_by_name[value.name] + if type(column) is not CompiledColumn: + _reject("unapproved Parquet column schema") + if type(value.mask) is not bool: + _reject("unapproved Parquet mask flag") + if not value.mask and (column.dtype is None or isinstance(column.spec, NDArraySpec)): + _reject("Parquet variable-length and ndarray columns need a registered expression adapter") + dtype = np.dtype(bool) if value.mask else column.dtype + if type(dtype) not in {type(np.dtype(name)) for name in _DTYPES} or type(value.dtype) is not type( + dtype + ): + _reject("unapproved Parquet column dtype metadata") + for extents in (value.shape, value.chunks, value.blocks): + if type(extents) is not tuple or any(type(n) is not int for n in extents): + _reject("unapproved Parquet column geometry metadata") + if value.shape != (storage.length,) or value.dtype != dtype or value.spec is not column.spec: + raise ValueError("Parquet column metadata no longer matches its storage") + + +def _validate_parquet_storage(storage): + with _parquet_storage_scope(storage): + pass + + +@contextlib.contextmanager +def _parquet_storage_scope(storage): + from blosc2.proxy import CacheCoordinator + from blosc2.remote_parquet import ParquetCache, ParquetTableStorage + from blosc2.remote_store import RemoteDiscovery + from blosc2.schema_compiler import CompiledSchema + + if type(storage) is not ParquetTableStorage: + _reject("unapproved Parquet column storage") + owner = storage._owner + if type(owner) is not RemoteDiscovery: + _reject("unapproved Parquet storage owner") + lock = owner.lock + if type(lock) is not _thread.RLock: + _reject("unapproved Parquet owner lock") + with lock: + if storage._owner is not owner or owner.lock is not lock: + raise ValueError("Parquet ownership changed during admission; retrieve a new handle") + if owner.parquet_cache is not None and ( + type(owner.parquet_cache) is not ParquetCache or owner.parquet_cache.owner is not owner + ): + _reject("unapproved Parquet cache owner") + if type(owner.cache_coordinator) is not CacheCoordinator: + _reject("unapproved Parquet cache coordinator") + if type(storage.schema) is not CompiledSchema or type(storage.schema.columns_by_name) is not dict: + _reject("unapproved Parquet schema metadata") + if type(storage.length) is not int or storage.length < 0: + _reject("unapproved Parquet row-count metadata") + storage._check_open() + yield + + +def _synchronize_remote_field(value): + fields = value.records.dtype.fields + if fields is None or type(value.field) is not str or value.field not in fields: + raise ValueError("Remote HDF5 field no longer refers to an existing structured field") + storage_dtype = fields[value.field][0] + if not value._logical_dtype_override: + value._dtype = storage_dtype + value._storage_dtype = storage_dtype + value._shape = tuple(value.records.shape) + value.chunks, value.blocks = value.records.chunks, value.records.blocks + + +def _validate_proxy_cache(value): + """Reject incompatible cache provenance without fetching or discarding data.""" + import blosc2 + + if value.src is not getattr(value, "_cache_source", None): + raise ValueError("Proxy source was rebound; construct a new proxy for the new source") + if type(value._cache) is not blosc2.NDArray: + _reject("expression proxy requires an admitted NDArray cache") + validate_operand(value._cache) + for name in ("shape", "dtype", "chunks", "blocks"): + if getattr(value.src, name) != getattr(value._cache, name): + raise ValueError(f"Proxy source/cache {name} mismatch; construct a new proxy") + + +def _synchronize_simple_proxy(value): + """Refresh wrapper metadata only after its source closure is admitted.""" + import blosc2 + + source = value._src + shape, dtype = tuple(source.shape), np.dtype(source.dtype) + if type(value._shape) is not tuple or any(type(n) is not int for n in value._shape): + _reject("unapproved SimpleProxy cached geometry") + _validated_dtype(value._dtype) + for extents in (value.chunks, value.blocks): + if extents is not None and ( + type(extents) is not tuple or any(not _axis_integer(n) or n <= 0 for n in extents) + ): + _reject("unapproved SimpleProxy cached chunk geometry") + if shape == value._shape and dtype == value._dtype: + return + chunks, blocks = value.chunks, value.blocks + if len(shape) != len(value._shape): + chunks, blocks = None, None + chunks, blocks = blosc2.compute_chunks_blocks(shape, chunks, blocks, dtype) + value._shape, value._dtype = shape, dtype + value.chunks, value.blocks = chunks, blocks + + +def _synchronize_ndfield(value): + """An admitted parent may have been rebound to a different field layout.""" + fields = value.ndarr.dtype.fields + if fields is None or type(value.field) is not str or value.field not in fields: + raise ValueError("NDField no longer refers to an existing structured field") + dtype, offset = fields[value.field][:2] + value._dtype, value.offset = dtype, offset + value.chunks, value.blocks = value.ndarr.chunks, value.ndarr.blocks + + +def validate_operands(operands): + _validate_operand_mapping(operands) + for value in operands.values(): + validate_operand(value) + + +def _validate_operand_mapping(operands): + if type(operands) not in (dict, OrderedDict): + _reject("unapproved expression operand mapping") + if any(type(name) not in (str, int) for name in operands): + _reject("unapproved expression operand key") + + +def normalize_operands(operands): + """Adapt a concrete numeric pandas Series without admitting arbitrary protocols.""" + pandas = sys.modules.get("pandas") + import blosc2 + + _validate_operand_mapping(operands) + result = dict(operands) + if pandas is not None: + for name, value in result.items(): + source = value._src if type(value) is blosc2.SimpleProxy else value + if type(source) is pandas.Series: + array = source._values + if type(array) is not np.ndarray: + _reject("pandas extension-array operand") + validate_operand(array) + result[name] = blosc2.SimpleProxy(array) if type(value) is blosc2.SimpleProxy else array + return result + + +def _dispatch(name, values, kwargs, prefer_blosc, *, method=False): + import blosc2 + from blosc2.utils import _NUMPY_ALIASES + + name, prefer_blosc = _qualified_reduction(name, prefer_blosc) + _check_call_contract(name, values, kwargs) + backend = _reduction_backend( + name, values[0] if values else None, method=method, prefer_blosc=prefer_blosc + ) + bound = _bind_reduction(name, values, kwargs, backend) + if bound is not None: + values, kwargs = values[:1], bound + if method: + receiver, *values = values + validate_operand(receiver) + if name == "astype" and type(receiver) is np.ndarray: + kwargs = _bind_numpy_cast([receiver, *values], kwargs) + values = [] + if name == "slice" and type(receiver) is np.ndarray: + # The scheduler rewrites indexing to NDArray.slice syntax. NumPy + # operands already reside in memory and use direct indexing instead. + if len(values) != 1 or kwargs: + _reject("NumPy slice requires exactly one index and no keywords") + return receiver[values[0]] + if name == "astype" and type(receiver) is not np.ndarray: + _reject("astype requires an admitted NumPy array; no streaming Blosc2 cast is registered") + # Receiver is admitted before accessing this explicitly registered method. + return getattr(receiver, name)(*values, **kwargs) + if name == "slice": + return slice(*values) + if name == "len": + return len(values[0]) + if name in _DTYPES: + return np.dtype(name).type(*values, **kwargs) + if name in {"where", "copy"} and values and type(values[0]) is np.ndarray: + return getattr(np, name)(*values, **kwargs) + if prefer_blosc and hasattr(blosc2, name): + return getattr(blosc2, name)(*values, **kwargs) + func = _NUMPY_ALIASES.get(name) or getattr(np, name, None) + if func is None: + _reject(f"no approved implementation for {name!r}") + return func(*values, **kwargs) + + +def evaluate_expression(text, globals_, operands): + """Evaluate a graph, or use the explicitly permitted legacy evaluator.""" + if evaluation_mode() == "full": + return eval(text, globals_, operands) + prefer_blosc = any(value is __import__("blosc2") for value in globals_.values()) + return parse_expression(text).evaluate(operands, prefer_blosc=prefer_blosc) + + +def evaluate_index(node): + return ExpressionGraph(node, frozenset(), "").evaluate({}) diff --git a/src/blosc2/graph_plan.py b/src/blosc2/graph_plan.py new file mode 100644 index 000000000..5f4235b2c --- /dev/null +++ b/src/blosc2/graph_plan.py @@ -0,0 +1,144 @@ +"""Explicit, opt-in native declarative numerical graph plans.""" + +from __future__ import annotations + +import json + +import numpy as np + +from . import blosc2_ext, jit_config +from .blosc2_ext import NativeGraphHandle + + +class NativeGraph: + """Immutable native graph/capture ownership, with no operand or result cache. + + This format is separate from portable elementwise artifact persistence. + Preparation and specialization require only explicit numerical metadata. + Compressed storage is adapted through invocation-local native graph readers. + """ + + def __init__(self, graph: str | bytes | dict, *, jit: bool | None = None, require_jit: bool = False): + jit = jit_config.execution_options()["jit"] if jit is None else jit + if isinstance(graph, dict): + graph = json.dumps(graph, separators=(",", ":")) + if isinstance(graph, str): + graph = graph.encode("utf-8") + if not isinstance(graph, bytes): + raise TypeError("Native graph must be declarative JSON") + mode = ( + 1 + if jit or require_jit + else getattr(blosc2_ext, "portable_auto_jit_mode", lambda: 0)() + if jit is None + else 2 + ) + self._handle = NativeGraphHandle(graph, mode, require_jit) + self._info = self._handle.info() + + @classmethod + def from_json(cls, graph, *, jit=None, require_jit=False): + return cls(graph, jit=jit, require_jit=require_jit) + + @classmethod + def from_expression(cls, expression, input_dtypes, *, jit=None, require_jit=False): + """Native restricted grammar, not a Python expression evaluator.""" + jit = jit_config.execution_options()["jit"] if jit is None else jit + if not isinstance(expression, str): + raise TypeError("Native expression must be text") + result = cls.__new__(cls) + mode = ( + 1 + if jit or require_jit + else getattr(blosc2_ext, "portable_auto_jit_mode", lambda: 0)() + if jit is None + else 2 + ) + result._handle = NativeGraphHandle.from_expression( + expression.encode("utf-8"), input_dtypes, mode, require_jit + ) + result._info = result._handle.info() + return result + + @property + def input_dtypes(self): + return dict(self._info["inputs"]) + + @property + def inferred_dtype(self): + return self._info["inferred_dtype"] + + @property + def has_jit(self): + return self._info["has_jit"] + + @property + def stages(self): + return self._info["stages"] + + @property + def partitionable(self): + return bool(self._info.get("partitionable", False)) + + def to_json(self): + """Canonical graph/captures only; importing always revalidates.""" + return self._handle.to_json() + + def info(self): + return {**self._info, "inputs": self.input_dtypes} + + def reduction_info(self): + """Borrowed root-reduction metadata; None for non-reduction graphs.""" + return self._handle.reduction_info() + + def specialize(self, inputs, tile_items=1024, *, intermediate_budget=0): + """Bind names to ``(dtype, shape)``; return an immutable owned schedule. + + Schedules retain their native plan and may outlive this Python object. + Query ``schedule.info()`` before allocating or reading numerical buffers; + execute with a name-to-NumPy-array mapping via ``schedule.execute(inputs)``. + """ + return self._handle.specialize(inputs, tile_items, intermediate_budget) + + def evaluate( + self, + inputs, + *, + tile_items=1024, + intermediate_budget=0, + raise_mask=0, + return_report=False, + out=None, + workers=1, + ): + if any(not isinstance(value, np.ndarray) for value in inputs.values()): + raise TypeError("Native graph evaluation requires explicit NumPy array buffers") + schedule = self.specialize( + {name: (value.dtype, value.shape) for name, value in inputs.items()}, + tile_items, + intermediate_budget=intermediate_budget, + ) + result, report = ( + schedule.execute(inputs, raise_mask) + if out is None and workers == 1 + else schedule.execute(inputs, raise_mask, out=out, workers=workers) + ) + return (result, report) if return_report else result + + def map_json(self): + """Export an eligible elementwise graph as a Menudet 1.0 artifact.""" + return self._handle.map_json() + + def evaluate_sources(self, inputs, *, tile_items=65536, raise_mask=0, return_report=False, out=None): + """Stream a single-region graph from NumPy/Blosc2 inputs with bounded scratch. + + Native traversal owns broadcasting, axes and serial reduction order. + Compressed operands are decoded only for requested tiles, never materialized. + Staged graphs and compressed participation masks remain unsupported. + """ + from .native_graph import evaluate_graph_sources + + result, report = evaluate_graph_sources( + self, inputs, tile_items=tile_items, raise_mask=raise_mask, out=out + ) + return (result, report) if return_report else result diff --git a/src/blosc2/lazyexpr.py b/src/blosc2/lazyexpr.py index 732c1141e..821d5ee0a 100644 --- a/src/blosc2/lazyexpr.py +++ b/src/blosc2/lazyexpr.py @@ -14,7 +14,6 @@ import contextlib import copy import enum -import inspect import linecache import math import operator @@ -22,12 +21,13 @@ import pathlib import re import sys -import textwrap import threading from abc import ABC, abstractmethod, abstractproperty +from collections import OrderedDict from collections.abc import MutableMapping -from dataclasses import asdict +from dataclasses import asdict, dataclass from enum import Enum +from functools import lru_cache from pathlib import Path from queue import Empty, Full, Queue from typing import TYPE_CHECKING, Any @@ -48,12 +48,27 @@ from .b2objects import ( encode_b2object_payload, + encode_operand_reference, make_b2object_carrier, read_b2object_user_vlmeta, write_b2object_payload, write_b2object_user_vlmeta, ) from .dsl_kernel import DSLKernel, DSLSyntaxError, DSLValidator, specialize_miniexpr_inputs +from .expression_graph import ( + arithmetic_names, + evaluate_expression, + evaluation_mode, + expression_constructor, + expression_evaluation, + expression_method, + expression_syntax, + normalize_operands, + parse_expression, + record_expression_metadata, + validate_operands, +) +from .prepared_evaluate import remember_evaluation from .proxy_source import convert_dtype from .utils import ( check_smaller_shape, @@ -77,19 +92,17 @@ try_miniexpr, ) -if not blosc2.IS_WASM: - import numexpr +numexpr = None # Compatibility placeholder; no runtime import or backend selection. -global safe_blosc2_globals -safe_blosc2_globals = {} +# Canonical expression text has no quoted strings or attribute names to rewrite. +_IDENTIFIER_RE = re.compile(r"\b[A-Za-z_]\w*\b") def _int64_datetime_operands(local_dict): """Return `local_dict` with datetime64/timedelta64 values viewed as int64. - numexpr has no datetime types, but both are int64 counts underneath, so a - comparison is exact in that representation -- and much faster than the - NumPy fallback. Returns None when the substitution would not be faithful: + Both are int64 counts underneath, so a comparison against a count is exact + in that representation. Returns None when the substitution would not be faithful: * mixed units, because the counts are then on different scales (NumPy promotes to the finer unit instead); @@ -104,7 +117,7 @@ def _int64_datetime_operands(local_dict): for key, value in local_dict.items(): dtype = getattr(value, "dtype", None) # Frame locals get merged in below, so `local_dict` also carries blosc2 - # containers that numexpr could not consume in the first place; leave + # containers that cannot be reinterpreted as resident counts; leave # anything that is not a NumPy value alone. if dtype is None or dtype.kind not in "Mm" or not isinstance(value, np.ndarray | np.generic): converted[key] = value @@ -126,87 +139,102 @@ def _numpy_eval_datetime_aware(expression, _globals, local_dict): else keeps NumPy's error. """ try: - return eval(expression, _globals, local_dict) + return evaluate_expression(expression, _globals, local_dict) except TypeError: int_dict = _int64_datetime_operands(local_dict) if int_dict is None: raise - res = eval(expression, _globals, int_dict) + res = evaluate_expression(expression, _globals, int_dict) if getattr(res, "dtype", None) != np.bool_: raise return res def ne_evaluate(expression, local_dict=None, **kwargs): - """Safely evaluate expressions using numexpr when possible, falling back to numpy.""" - if local_dict is None: - local_dict = {} - # Get local vars dict from the stack frame - _frame_depth = kwargs.pop("_frame_depth", 1) - local_dict |= { - k: v - for k, v in dict(sys._getframe(_frame_depth).f_locals).items() - if ( - (hasattr(v, "shape") or np.isscalar(v)) - and - # Do not overwrite the local_dict with the expression variables - not (k in local_dict or k in ("_where_x", "_where_y")) + """Legacy internal name for native/NumPy chunk evaluation; no NumExpr usage.""" + kwargs.setdefault("_frame_depth", 1) + return evaluate_chunk(expression, local_dict, **kwargs) + + +def evaluate_chunk(expression, local_dict=None, **kwargs): + """Evaluate an invocation-local chunk with native numerical or NumPy semantics. + + Native admission is metadata-only. Unsupported signatures decline before + execution; runtime failures are never replayed through NumPy. + """ + from .native_graph import _native_first_syntax, lower_native_graph + + operands = {} if local_dict is None else dict(local_dict) + depth = kwargs.pop("_frame_depth", 0) + graph = parse_expression(expression) + if graph.names - operands.keys(): + frame = sys._getframe(depth + 1) + try: + for name in graph.names - operands.keys(): + if name in frame.f_locals: + operands[name] = frame.f_locals[name] + elif name in frame.f_globals: + operands[name] = frame.f_globals[name] + finally: + del frame + validate_operands(operands) + output = kwargs.pop("out", None) + validate_evaluate_options(kwargs) + policy = blosc2.jit_config.execution_options() + native = None + if ( + operands + and _native_first_syntax(expression) + and all(type(value) is np.ndarray and value.dtype.kind in "biuf" for value in operands.values()) + and not (output is not None and any(np.shares_memory(output, value) for value in operands.values())) + ): + stub = LazyExpr(None) + stub.expression, stub.operands = expression, operands + try: + # Chunk fallback must not silently force the scalar interpreter for + # numerical graphs that already have qualified native C lowering. + # Explicit no-JIT policy still wins; native compilation remains + # best effort and cached by expression/signature, never by arrays. + graph_jit = ( + policy["jit"] + if policy["jit_backend"] is None and policy["fp_accuracy"] == blosc2.FPAccuracy.DEFAULT + else False + ) + native = lower_native_graph(stub, jit=graph_jit, allow_output=True) + except (NotImplementedError, ValueError, TypeError): + native = None + except blosc2.PortableArtifactError as error: + if error.status not in {"invalid_signature", "unsupported"}: + raise + if native is not None: + plan, arrays, _ = native + # Match the native executor's bounded map tiles without starting another + # pool inside a caller-owned chunk/compression worker. Checked recipes + # and reductions retain their existing numerical traversal. + tile_items = 65536 if plan.info().get("partitionable", False) else 1024 + schedule = plan.specialize( + {name: (value.dtype, value.shape) for name, value in arrays.items()}, tile_items=tile_items ) - } - if blosc2.IS_WASM: - global safe_numpy_globals - populate_safe_numpy_globals(expression) - if "out" in kwargs: - out = kwargs.pop("out") - out[:] = _numpy_eval_datetime_aware(expression, safe_numpy_globals, local_dict) - return out - res = _numpy_eval_datetime_aware(expression, safe_numpy_globals, local_dict) - return np.asarray(res) if not hasattr(res, "shape") else res - try: - return numexpr.evaluate(expression, local_dict=local_dict, **kwargs) - except ValueError as e: - msg = e.args[0] if e.args else "" - if msg == "NumExpr 2 does not support Unicode as a dtype.": - pass - elif msg.startswith(("unknown type datetime64", "unknown type timedelta64")): - int_dict = _int64_datetime_operands(local_dict) - if int_dict is not None: - with contextlib.suppress(Exception): - result = numexpr.evaluate(expression, local_dict=int_dict, **kwargs) - if result.dtype == np.bool_: - return result - # Only comparisons are exact as raw int64 counts; arithmetic - # (datetime64 - datetime64 -> timedelta64) needs NumPy's own type - # rules, so let it reach the fallback below. - else: - raise # unsafe expression - except Exception: - pass - # Try with blosc2 funcs as presence of non-numexpr funcs probably caused failure - # ne_evaluate will need safe_blosc2_globals for some functions (e.g. clip, logaddexp, - # startswith, matmul) that are implemented incompletely in numexpr/miniexpr or not implemented at all - global safe_blosc2_globals - if len(safe_blosc2_globals) == 0: - # First eval call, fill blosc2_safe_globals - safe_blosc2_globals = {"blosc2": blosc2} - # Add all first-level blosc2 functions - safe_blosc2_globals.update( - { - name: getattr(blosc2, name) - for name in dir(blosc2) - if callable(getattr(blosc2, name)) and not name.startswith("_") - } + info = schedule.info() + direct = ( + output is not None + and type(output) is np.ndarray + and output.shape == info["shape"] + and output.dtype == info["dtype"] + and getattr(blosc2.blosc2_ext, "native_graph_output_available", lambda: False)() ) - # Expression strings can carry non-finite float literals ("nan", - # "inf" — the repr of such scalars, or typed by the user); numexpr - # has no such constants, so this python-eval fallback must. - safe_blosc2_globals.update({"nan": math.nan, "inf": math.inf}) - res = eval(expression, safe_blosc2_globals, local_dict) - if "out" in kwargs: - out = kwargs.pop("out") - out[:] = res # will handle calc/decomp if res is lazyarray - return out - return res[()] if isinstance(res, blosc2.Operand) else res + result, _ = schedule.execute(arrays, out=output) if direct else schedule.execute(arrays) + else: + # Native chunk execution collects FP status without emitting Python + # warnings by default. Preserve that policy in the explicit fallback. + with np.errstate(all="ignore"): + result = _numpy_eval_datetime_aware(expression, safe_numpy_globals, operands) + result = np.asarray(result) + if output is not None: + if result is not output: + np.copyto(output, result, casting=kwargs.get("casting", "same_kind")) + return output + return result def _get_result(expression, chunk_operands, ne_args, where=None, indices=None, _order=None): @@ -216,13 +244,13 @@ def _get_result(expression, chunk_operands, ne_args, where=None, indices=None, _ if where is not None and len(where) == 2: # x = chunk_operands["_where_x"] # y = chunk_operands["_where_y"] - # numexpr is a bit faster than np.where, and we can fuse operations in this case + # Preserve a fused native select when the expression is supported. new_expr = f"where({expression}, _where_x, _where_y)" return ne_evaluate(new_expr, chunk_operands, **ne_args), None # If the expression is a simple operand reference (e.g. "key", "o0"), # grab it directly from chunk_operands instead of calling ne_evaluate. - # This avoids ~150 µs of numexpr parsing/setup overhead per chunk. + # This avoids unnecessary expression preparation for identity chunks. _expr = expression.strip("()") if _expr in chunk_operands: result = chunk_operands[_expr] @@ -353,6 +381,9 @@ def _find_constructor_call(expression: str, constructor: str) -> re.Match | None def get_expr_globals(expression): """Build a dictionary of functions needed for evaluating the expression.""" + if evaluation_mode() == "safe": + parse_expression(expression) + return {"blosc2": blosc2} _globals = {"np": np, "blosc2": blosc2, "nan": math.nan, "inf": math.inf} # Only check for functions that actually appear in the expression. for func in functions: @@ -891,6 +922,9 @@ def validate_expr(expr: str) -> None: ------- None """ + if evaluation_mode() == "safe": + parse_expression(expr) + return # Remove whitespace and skip quoted strings no_whitespace = re.sub(r"\s+", "", expr) skip_quotes = re.sub(r"(\'[^\']*\')", "", no_whitespace) @@ -1030,6 +1064,8 @@ def conserve_functions( # noqa: C901 expression: str, operands_old: dict[str, blosc2.Array], operands_new: dict[str, blosc2.Array], + *, + tree=None, ) -> tuple[str, dict[str, blosc2.Array]]: """ Given an expression in string form, return its operands. @@ -1090,7 +1126,7 @@ def update_func(self, localop): return self.operandmap[k] def visit_Name(self, node): - if node.id == "np": # Skip NumPy namespace (e.g. np.int8, which will be treated separately) + if node.id in {"np", "numpy", "blosc2"}: # Registered namespaces are not operands return if node.id in self.function_names: # Skip function names return @@ -1122,7 +1158,18 @@ def visit_Call(self, node): self.function_names.add(node.func.id) self.generic_visit(node) - tree = ast.parse(expression) + if tree is None: + tree = ast.parse(expression) + else: + # Renaming must not mutate syntax shared by other expressions or threads. + def clone(node): + if isinstance(node, ast.AST): + return type(node)(**{name: clone(value) for name, value in ast.iter_fields(node)}) + if isinstance(node, list): + return [clone(value) for value in node] + return node + + tree = clone(tree) visitor = OperandVisitor() visitor.visit(tree) newexpression, newoperands = ast.unparse(tree), visitor.operands @@ -1151,7 +1198,11 @@ def convert_to_slice(expression): k = expression[i:].find("]") # start checking from after [ slice_convert = expression[i : i + k + 1] # include [ and ] try: - slicer = eval(f"np.s_{slice_convert}") + slicer = parse_expression(f"a{slice_convert}").root[2] + # Build the slice tuple directly without indexing an actual array. + from .expression_graph import evaluate_index + + slicer = evaluate_index(slicer) slicer = (slicer,) if not isinstance(slicer, tuple) else slicer # standardise to tuple if any(isinstance(el, str) for el in slicer): # handle fields raise ValueError("Cannot handle fields for slicing lazy expressions.") @@ -1530,6 +1581,10 @@ def fill_chunk_operands( def _apply_jit_backend_pragma(expression: str, inputs: dict, jit_backend: str | None) -> str: + # Author-written pragmas are authoritative. Python's synthesized pragma is + # only a local default and must not override the native environment policy. + if "# me:compiler=" in expression: + return expression if jit_backend is None: return expression if jit_backend == "js": @@ -1538,11 +1593,15 @@ def _apply_jit_backend_pragma(expression: str, inputs: dict, jit_backend: str | if jit_backend not in ("tcc", "cc"): raise ValueError("jit_backend must be one of: None, 'tcc', 'cc', 'js'") + env_backend = os.environ.get("ME_DSL_JIT_COMPILER", "").strip().lower() + if env_backend in ("tcc", "cc"): + jit_backend = env_backend + pragma = f"# me:compiler={jit_backend}\n" - stripped = expression.lstrip() + stripped = "\n".join( + line for line in expression.splitlines() if not line.lstrip().startswith("#") + ).lstrip() if stripped.startswith("def "): - if "# me:compiler=" in expression: - return expression return pragma + expression params = ", ".join(k for k, v in inputs.items() if hasattr(v, "dtype")) return f"{pragma}def __me_auto({params}):\n return {expression}" @@ -1778,7 +1837,7 @@ def fast_eval( # noqa: C901 if isinstance(out, blosc2.NDArray): # If 'out' has been passed, and is a NDArray, use it as the base array basearr = out - elif isinstance(out, np.ndarray): + elif isinstance(out, np.ndarray) and not any(hasattr(o, "chunks") for o in operands.values()): # If 'out' is a NumPy array, create a NDArray with the same shape and dtype basearr = blosc2.empty(out.shape, dtype=out.dtype, **kwargs) else: @@ -1874,8 +1933,8 @@ def _miniexpr_eligible_operand(op): if isinstance(op, np.ndarray): # Raw NumPy operands are only miniexpr-eligible for DSL kernels (the # jit control-flow dispatch route). Plain string expressions and traced - # `jit` calls keep the old NDArray-only gate, so their numeric behavior - # (e.g. transcendentals matching numexpr bit-for-bit) is unchanged. + # `jit` calls keep the established NDArray-only gate, preserving + # existing numerical and dtype behavior. return ( is_dsl and op.ndim > 0 @@ -1892,7 +1951,18 @@ def _miniexpr_eligible_operand(op): dsl_disable_reason = ( "all DSL operands must be NDArray or NumPy inputs sharing shape/chunks/blocks." ) - if not (all_eligible_miniexpr and out is None): + numpy_output = ( + (getitem or isinstance(out, np.ndarray)) + and len(shape) == 1 + and chunks[0] % blocks[0] == 0 + and not prune_chunks + and (out is None or not is_dsl) + # Rebinding an existing LazyExpr can leave unused operand names. + # Retain its established fallback rather than compiling extra inputs. + and (is_dsl or set(operands_miniexpr) == set(get_expr_operands(expr_string))) + and (out is None or (out.dtype == dtype and out.flags.writeable)) + ) + if not (all_eligible_miniexpr and (out is None or numpy_output)): use_miniexpr = False if is_dsl and dsl_disable_reason is None: dsl_disable_reason = ( @@ -1902,16 +1972,14 @@ def _miniexpr_eligible_operand(op): isinstance(op, blosc2.NDArray) and blosc2.isdtype(op.dtype, "complex floating") for op in operands_miniexpr.values() ) - if isinstance(expr_string_miniexpr, str) and has_complex: - if sys.platform == "win32" or blosc2.IS_WASM: - # On Windows and WebAssembly, miniexpr has issues with complex numbers - use_miniexpr = False - if is_dsl and dsl_disable_reason is None: - dsl_disable_reason = "complex DSL kernels are disabled on Windows and WebAssembly." - if any(tok in expr_string_miniexpr for tok in ("!=", "==", "<=", ">=", "<", ">")): - use_miniexpr = False - if is_dsl and dsl_disable_reason is None: - dsl_disable_reason = "complex comparisons are not supported by miniexpr." + if ( + isinstance(expr_string_miniexpr, str) + and has_complex + and any(tok in expr_string_miniexpr for tok in ("!=", "==", "<=", ">=", "<", ">")) + ): + use_miniexpr = False + if is_dsl and dsl_disable_reason is None: + dsl_disable_reason = "complex comparisons are not supported by miniexpr." if is_dsl and not use_miniexpr: _raise_dsl_miniexpr_required(dsl_disable_reason) @@ -1931,9 +1999,10 @@ def _miniexpr_eligible_operand(op): if use_miniexpr: cparams = kwargs.pop("cparams", None) - if cparams is None and getitem: - # getitem output is throwaway scratch (returned as a NumPy array and - # discarded), so compressing it buys nothing but a round trip. + if numpy_output: + # NumPy output needs only an uncompressed, reusable chunk payload. + cparams = blosc2.CParams(clevel=0) + elif cparams is None and getitem: cparams = blosc2.CParams(clevel=0) # Otherwise leave cparams unset rather than passing CParams(): its # filters_meta defaults to all zeros, which *overrides* the dtype-aware @@ -1968,6 +2037,22 @@ def _miniexpr_eligible_operand(op): # print("expr->miniexpr:", expression, fp_accuracy) # Data to compress is fetched from operands, so it can be uninitialized here data = np.empty(res_eval.schunk.chunksize, dtype=np.uint8) + if numpy_output: + output_storage = None + if out is None: + # Reserve a header prefix and at most one chunk of tail + # padding. C-Blosc2 can then write each uncompressed payload + # directly into the final NumPy allocation, in parallel. + output_storage = np.empty( + res_eval.schunk.nchunks * data.size + blosc2.EXTENDED_HEADER_LENGTH, dtype=np.uint8 + ) + out = np.ndarray( + shape, dtype=dtype, buffer=output_storage, offset=blosc2.EXTENDED_HEADER_LENGTH + ) + else: + # Caller-owned output has no reserved header prefix. Keep + # the existing buffer and reuse bounded chunk scratch. + chunk_data = np.empty(data.size + blosc2.MAX_OVERHEAD, dtype=np.uint8) # Exercise prefilter for each chunk. With a candidate bitmap the # prefilter zeroes non-candidate blocks without decompressing inputs # or running miniexpr, which is where the savings come from. With @@ -1982,12 +2067,34 @@ def _miniexpr_eligible_operand(op): for nchunk in range(res_eval.schunk.nchunks): if chunk_has_candidate is not None and not chunk_has_candidate[nchunk]: continue - res_eval.schunk.update_data(nchunk, data, copy=False) + if numpy_output: + start = nchunk * chunks[0] + count = min(chunks[0], shape[0] - start) + if output_storage is not None: + byte_start = nchunk * data.size + chunk_data = output_storage[ + byte_start : byte_start + data.size + blosc2.EXTENDED_HEADER_LENGTH + ] + # Beyond the first chunk the header overlaps the end of + # the preceding result. Preserve it while this synchronous + # call runs, then restore before advancing to the next chunk. + header = chunk_data[: blosc2.EXTENDED_HEADER_LENGTH].copy() + try: + res_eval.schunk._prefilter_data(nchunk, data, chunk_data) + finally: + chunk_data[: blosc2.EXTENDED_HEADER_LENGTH] = header + else: + res_eval.schunk._prefilter_data(nchunk, data, chunk_data) + values = np.frombuffer( + chunk_data, dtype=dtype, count=count, offset=blosc2.EXTENDED_HEADER_LENGTH + ) + out[start : start + count] = values + else: + res_eval.schunk.update_data(nchunk, data, copy=False) # _cb_anchor (if any) stays referenced until fast_eval returns, which # is after the finally below removes the prefilter — so the buffer # safely outlives every prefilter dereference. except Exception as e: - use_miniexpr = False if is_dsl: reason = ( f"miniexpr compilation or execution failed for this DSL kernel:\n{expression.dsl_source}" @@ -2002,6 +2109,12 @@ def _miniexpr_eligible_operand(op): raise RuntimeError(_dsl_miniexpr_required_message(reason)) from e if strict_miniexpr: raise RuntimeError("miniexpr evaluation failed while strict_miniexpr=True") from e + # Only preparation may decline to NumPy. Once installed, the native + # prefilter may have written caller output or compressed chunks; + # replaying an execution failure would hide errors/partial writes. + if prefilter_set: + raise + use_miniexpr = False finally: if prefilter_set: res_eval.schunk.remove_prefilter("miniexpr") @@ -2014,6 +2127,8 @@ def _miniexpr_eligible_operand(op): # (continue to the manual chunked evaluation below) pass else: + if numpy_output: + return out if getitem: return res_eval[()] return res_eval @@ -2074,12 +2189,12 @@ def _miniexpr_eligible_operand(op): raise ValueError("Fast path: the where condition must be a tuple with two elements") # Store the result in the output array - if getitem: + if getitem or isinstance(out, np.ndarray): try: out[cslice] = result except ComplexWarning: - # The result is a complex number, so we need to convert it to real. - # This is a workaround for rigidness of NumExpr with type casting. + # The result is complex while the destination is real; preserve + # the established explicit destination-conversion behavior. result = result.real.astype(out.dtype) out[cslice] = result else: @@ -2528,8 +2643,8 @@ def slices_eval_getitem( # A UDF writes into an output of slice_shape, which keeps the integer-indexed # axes as length 1; slicing its operands with the raw index would drop those # axes and leave the kernel unable to write its result (e.g. `udf[:, 0]` on a - # 2-dim array: operand (10,) into output (10, 1)). numexpr has no output - # buffer to agree with, so it keeps the raw index. + # 2-dim array: operand (10,) into output (10, 1)). Plain expressions keep + # the raw index; their result no longer carries an explicit UDF destination. op_slice = _slice_bcast if callable(expression) else _slice # Get the slice of each operand @@ -2733,8 +2848,9 @@ def reduce_slices( # noqa: C901 if ne_args is None: ne_args = {} fp_accuracy = kwargs.pop("fp_accuracy", blosc2.FPAccuracy.DEFAULT) - jit = kwargs.pop("jit", None) - jit_backend = kwargs.pop("jit_backend", None) + # Scalar native reductions cannot use elementwise DSL JIT output buffers. + kwargs.pop("jit", None) + kwargs.pop("jit_backend", None) where: dict | None = kwargs.pop("_where_args", None) reduce_op = reduce_args.pop("op") reduce_op_str = reduce_args.pop("op_str", None) @@ -2868,9 +2984,6 @@ def reduce_slices( # noqa: C901 isinstance(op, blosc2.NDArray) and blosc2.isdtype(op.dtype, "complex floating") for op in operands.values() ) - if has_complex and (sys.platform == "win32" or blosc2.IS_WASM): - # On Windows and WebAssembly, miniexpr has issues with complex numbers - use_miniexpr = False if has_complex and any(tok in expression for tok in ("!=", "==", "<=", ">=", "<", ">")): use_miniexpr = False if where is not None and len(where) != 2: @@ -2912,8 +3025,13 @@ def reduce_slices( # noqa: C901 expression_miniexpr = f"{reduce_op_str}(where({expression}, _where_x, _where_y))" else: expression_miniexpr = f"{reduce_op_str}({expression})" - expression_miniexpr = _apply_jit_backend_pragma(expression_miniexpr, operands, jit_backend) - res_eval._set_pref_expr(expression_miniexpr, operands, fp_accuracy, aux_reduc, jit=jit) + # Keep reductions as native scalar expressions. A DSL return + # broadcasts a reduced value across the output block, whereas this + # prefilter supplies only one accumulator slot per block. Explicit + # JIT_ON also auto-lifts plain expressions in the native compiler, + # so use the scalar interpreter until reduction JIT has a separate + # output-cardinality contract. + res_eval._set_pref_expr(expression_miniexpr, operands, fp_accuracy, aux_reduc, jit=False) prefilter_set = True # print("expr->miniexpr:", expression, reduce_op, fp_accuracy) # Data won't even try to be compressed, so buffers can be unitialized and reused @@ -2923,7 +3041,6 @@ def reduce_slices( # noqa: C901 for nchunk in range(res_eval.schunk.nchunks): res_eval.schunk._prefilter_data(nchunk, data, chunk_data) except Exception as e: - use_miniexpr = False if callable(expression) and _is_dsl_kernel_expression(expression): reason = "miniexpr compilation or execution failed for this DSL kernel." backend_error = str(e) @@ -2934,6 +3051,9 @@ def reduce_slices( # noqa: C901 if parse_hint is not None: reason = f"{reason}\n{parse_hint}" raise RuntimeError(_dsl_miniexpr_required_message(reason)) from e + if prefilter_set: + raise + use_miniexpr = False finally: if prefilter_set: res_eval.schunk.remove_prefilter("miniexpr") @@ -3298,7 +3418,7 @@ def chunked_eval( # noqa: C901 _output: blosc2.Array, optional The output array to store the result. _ne_args: dict, optional - Additional arguments to be passed to `numexpr.evaluate()` function. + Compatibility expression options, validated independently of backend. _where_args: dict, optional Additional arguments for conditional evaluation. """ @@ -3400,11 +3520,10 @@ def chunked_eval( # noqa: C901 **kwargs, ) elif (kwargs.get("chunks") is None and kwargs.get("blocks") is None) and ( - out is None or isinstance(out, blosc2.NDArray) + out is None or isinstance(out, (blosc2.NDArray, np.ndarray)) ): # If not, the conditions to use the fast path are a bit more restrictive - # e.g. the user cannot specify chunks or blocks, or an output that is not - # a blosc2.NDArray + # e.g. the user cannot specify chunks or blocks here. return fast_eval( expression, operands, @@ -3563,6 +3682,27 @@ def result_type( return np.result_type(*arrs) +def _arithmetic_recipe_text(expression, operands): + """Canonical operand text for an eligible binary arithmetic expression. + + Returns ``None`` unless every operand is an exact expression name and the + graph is plain binary arithmetic with ASCII names. Canonical text comes from + the shared syntax tree, so no graph lowering is needed. + """ + names = arithmetic_names(expression) + if ( + names is None + or len(names) != len(operands) + or not all(type(name) is str for name in operands) + or names != tuple(sorted(operands)) + ): + return None + tree, _ = expression_syntax(expression) + if not isinstance(tree.body, ast.BinOp) or not all(name.isascii() for name in names): + return None + return ast.unparse(tree.body) + + def can_cast(from_: blosc2.dtype | blosc2.NDArray, to: blosc2.dtype) -> bool: """ Determines if one data type can be cast to another data type according to (NumPy) type promotion rules. @@ -3592,6 +3732,7 @@ class LazyExpr(LazyArray): Once the lazy expression is created, it can be evaluated via :func:`LazyExpr.compute`. """ + @expression_constructor def __init__(self, new_op): # noqa: C901 if new_op is None: self.expression = "" @@ -3634,7 +3775,8 @@ def __init__(self, new_op): # noqa: C901 # Reset values represented as np.int64 etc. to be set as Python natives, # BUT preserve numpy integer scalars that require explicit typing (unsigned or - # 64-bit) so that dtype-sensitive backends (numexpr) don't downcast them to int32. + # 64-bit) so that expression preparation preserves their explicit dtype + # instead of normalizing them to a narrower Python integer. def _to_native_if_safe(v): if not (np.isscalar(v) and hasattr(v, "item")): return v @@ -3727,97 +3869,93 @@ def _retype_nonfinite(v): self.operands = {"o0": value1, "o1": value2} self.expression = f"(o0 {op} o1)" + @expression_method def update_expr(self, new_op): - prev_flag = blosc2._disable_overloaded_equal - # We use a lot of the original NDArray.__eq__ as 'is', so deactivate the overloaded one - blosc2._disable_overloaded_equal = True - # One of the two operands are LazyExpr instances - try: - value1, op, value2 = new_op - value1 = value1._raw_col if hasattr(value1, "_raw_col") else value1 - value2 = value2._raw_col if hasattr(value2, "_raw_col") else value2 - dtype_ = check_dtype(op, value1, value2) # conserve dtype - # The new expression and operands - expression = None - new_operands = {} - # where() handling requires evaluating the expression prior to merge. - # This is different from reductions, where the expression is evaluated - # and returned a NumPy array (for usability convenience). - # We do things like this to enable the fusion of operations like - # `a.where(0, 1).sum()`. - # Another possibility would have been to always evaluate where() and produce - # an NDArray, but that would have been less efficient for the case above. - if hasattr(value1, "_where_args"): - value1 = value1.compute() - if hasattr(value2, "_where_args"): - value2 = value2.compute() - - if not isinstance(value1, LazyExpr) and not isinstance(value2, LazyExpr): - # We converted some of the operands to NDArray (where() handling above) - new_operands = {"o0": value1, "o1": value2} - expression = "op(o0, o1)" if op in funcs_2args else f"(o0 {op} o1)" - return self._new_expr(expression, new_operands, guess=False, out=None, where=None) - elif isinstance(value1, LazyExpr) and isinstance(value2, LazyExpr): - # Expression fusion - # Fuse operands in expressions and detect duplicates - new_operands, dup_op = fuse_operands(value1.operands, value2.operands) - # Take expression 2 and rebase the operands while removing duplicates - new_expr = fuse_expressions(value2.expression, len(value1.operands), dup_op) + # Operand deduplication uses identity; never change global equality + # behavior while other threads may be constructing expressions. + value1, op, value2 = new_op + value1 = value1._raw_col if hasattr(value1, "_raw_col") else value1 + value2 = value2._raw_col if hasattr(value2, "_raw_col") else value2 + dtype_ = check_dtype(op, value1, value2) # conserve dtype + # The new expression and operands + expression = None + new_operands = {} + # where() handling requires evaluating the expression prior to merge. + # This is different from reductions, where the expression is evaluated + # and returned a NumPy array (for usability convenience). + # We do things like this to enable the fusion of operations like + # `a.where(0, 1).sum()`. + # Another possibility would have been to always evaluate where() and produce + # an NDArray, but that would have been less efficient for the case above. + if hasattr(value1, "_where_args"): + value1 = value1.compute() + if hasattr(value2, "_where_args"): + value2 = value2.compute() + + if not isinstance(value1, LazyExpr) and not isinstance(value2, LazyExpr): + # We converted some of the operands to NDArray (where() handling above) + new_operands = {"o0": value1, "o1": value2} + expression = "op(o0, o1)" if op in funcs_2args else f"(o0 {op} o1)" + return self._new_expr(expression, new_operands, guess=False, out=None, where=None) + elif isinstance(value1, LazyExpr) and isinstance(value2, LazyExpr): + # Expression fusion + # Fuse operands in expressions and detect duplicates + new_operands, dup_op = fuse_operands(value1.operands, value2.operands) + # Take expression 2 and rebase the operands while removing duplicates + new_expr = fuse_expressions(value2.expression, len(value1.operands), dup_op) + expression = ( + f"{op}({value1.expression}, {new_expr})" + if op in funcs_2args + else f"({value1.expression} {op} {new_expr})" + ) + def_operands = value1.operands + elif isinstance(value1, LazyExpr): + if np.isscalar(value2): + v2 = format_expr_scalar(value2) + elif hasattr(value2, "shape") and value2.shape == (): + v2 = format_expr_scalar(value2[()]) + else: + operand_to_key = {id(v): k for k, v in value1.operands.items()} + try: + v2 = operand_to_key[id(value2)] + except KeyError: + v2 = f"o{len(value1.operands)}" + new_operands = {v2: value2} + if op == "~": + expression = f"({op}{value1.expression})" + else: expression = ( - f"{op}({value1.expression}, {new_expr})" + f"{op}({value1.expression}, {v2})" if op in funcs_2args - else f"({value1.expression} {op} {new_expr})" + else f"({value1.expression} {op} {v2})" ) - def_operands = value1.operands - elif isinstance(value1, LazyExpr): - if np.isscalar(value2): - v2 = format_expr_scalar(value2) - elif hasattr(value2, "shape") and value2.shape == (): - v2 = format_expr_scalar(value2[()]) - else: - operand_to_key = {id(v): k for k, v in value1.operands.items()} - try: - v2 = operand_to_key[id(value2)] - except KeyError: - v2 = f"o{len(value1.operands)}" - new_operands = {v2: value2} - if op == "~": - expression = f"({op}{value1.expression})" - else: - expression = ( - f"{op}({value1.expression}, {v2})" - if op in funcs_2args - else f"({value1.expression} {op} {v2})" - ) - def_operands = value1.operands + def_operands = value1.operands + else: + if np.isscalar(value1): + v1 = format_expr_scalar(value1) + elif hasattr(value1, "shape") and value1.shape == (): + v1 = format_expr_scalar(value1[()]) else: - if np.isscalar(value1): - v1 = format_expr_scalar(value1) - elif hasattr(value1, "shape") and value1.shape == (): - v1 = format_expr_scalar(value1[()]) - else: - operand_to_key = {id(v): k for k, v in value2.operands.items()} - try: - v1 = operand_to_key[id(value1)] - except KeyError: - v1 = f"o{len(value2.operands)}" - new_operands = {v1: value1} - if op == "[]": # syntactic sugar for slicing - expression = f"({v1}[{value2.expression}])" - else: - expression = ( - f"{op}({v1}, {value2.expression})" - if op in funcs_2args - else f"({v1} {op} {value2.expression})" - ) - def_operands = value2.operands - # Return a new expression - operands = def_operands | new_operands - expr = self._new_expr(expression, operands, guess=False, out=None, where=None) - expr._dtype = dtype_ # override dtype with preserved dtype - return expr - finally: - blosc2._disable_overloaded_equal = prev_flag + operand_to_key = {id(v): k for k, v in value2.operands.items()} + try: + v1 = operand_to_key[id(value1)] + except KeyError: + v1 = f"o{len(value2.operands)}" + new_operands = {v1: value1} + if op == "[]": # syntactic sugar for slicing + expression = f"({v1}[{value2.expression}])" + else: + expression = ( + f"{op}({v1}, {value2.expression})" + if op in funcs_2args + else f"({v1} {op} {value2.expression})" + ) + def_operands = value2.operands + # Return a new expression + operands = def_operands | new_operands + expr = self._new_expr(expression, operands, guess=False, out=None, where=None) + expr._dtype = dtype_ # override dtype with preserved dtype + return expr def _miniexpr_string_dtype(self): """Width of a string-valued result, as inferred by miniexpr itself. @@ -3861,6 +3999,7 @@ def _miniexpr_string_dtype(self): return out @property + @expression_method def dtype(self): # miniexpr owns string widths; see _miniexpr_string_dtype. string_dtype = self._miniexpr_string_dtype() @@ -3892,6 +4031,7 @@ def ndim(self) -> int: return len(self.shape) @property + @expression_method def shape(self): # Honor self._shape; it can be set during the building of the expression if hasattr(self, "_shape"): @@ -3925,6 +4065,7 @@ def shape(self): return _shape @property + @expression_method def chunks(self): if hasattr(self, "_chunks"): return self._chunks @@ -3941,6 +4082,7 @@ def chunks(self): return self._chunks @property + @expression_method def blocks(self): if hasattr(self, "_blocks"): return self._blocks @@ -3956,6 +4098,7 @@ def blocks(self): self._chunks, self._blocks = compute_chunks_blocks(self.shape, None, None, dtype=self.dtype) return self._blocks + @expression_method def where(self, value1=None, value2=None): """ Select value1 or value2 values based on the condition of the current expression. @@ -3972,6 +4115,8 @@ def where(self, value1=None, value2=None): out: LazyExpr A new expression with the where condition applied. """ + if evaluation_mode() == "safe": + validate_operands({"value1": value1, "value2": value2}) if not np.issubdtype(self.dtype, np.bool_): raise ValueError("where() can only be used with boolean expressions") # This just acts as a 'decorator' for the existing expression @@ -3997,12 +4142,16 @@ def where(self, value1=None, value2=None): new_expr.operands = self.operands new_expr._where_args = args new_expr._dtype = dtype + if evaluation_mode() == "safe": + record_expression_metadata(new_expr) return new_expr @staticmethod def _normalize_where(where): if where is None: return None + if evaluation_mode() == "safe": + validate_operands({"where": where}) raw_col = getattr(where, "_raw_col", None) if raw_col is not None: where = raw_col @@ -4034,6 +4183,7 @@ def _reduction_identity(self, op): return np.inf if op == "min" else -np.inf raise TypeError(f"where= for {op} is not supported for dtype {dtype!r}") + @expression_method def sum( self, axis=None, @@ -4056,6 +4206,7 @@ def sum( } return self.compute(_reduce_args=reduce_args, fp_accuracy=fp_accuracy, **kwargs) + @expression_method def prod( self, axis=None, @@ -4102,6 +4253,7 @@ def get_num_elements(self, axis, item, fp_accuracy=None, **execution_kwargs): axis = tuple(a if a >= 0 else a + len(shape) for a in axis) # handle negative indexing return math.prod([shape[i] for i in axis]) + @expression_method def mean( self, axis=None, @@ -4141,6 +4293,7 @@ def mean( out = blosc2.asarray(out, **kwargs) return out + @expression_method def std( self, axis=None, @@ -4204,6 +4357,7 @@ def std( out = blosc2.asarray(out, **kwargs) return out + @expression_method def var( self, axis=None, @@ -4265,6 +4419,7 @@ def var( out = blosc2.asarray(out, **kwargs) return out + @expression_method def min( self, axis=None, @@ -4286,6 +4441,7 @@ def min( } return self.compute(_reduce_args=reduce_args, fp_accuracy=fp_accuracy, **kwargs) + @expression_method def max( self, axis=None, @@ -4307,6 +4463,7 @@ def max( } return self.compute(_reduce_args=reduce_args, fp_accuracy=fp_accuracy, **kwargs) + @expression_method def any( self, axis=None, @@ -4322,6 +4479,7 @@ def any( } return self.compute(_reduce_args=reduce_args, fp_accuracy=fp_accuracy, **kwargs) + @expression_method def all( self, axis=None, @@ -4337,6 +4495,7 @@ def all( } return self.compute(_reduce_args=reduce_args, fp_accuracy=fp_accuracy, **kwargs) + @expression_method def argmax( self, axis=None, @@ -4351,6 +4510,7 @@ def argmax( } return self.compute(_reduce_args=reduce_args, fp_accuracy=fp_accuracy, **kwargs) + @expression_method def argmin( self, axis=None, @@ -4441,13 +4601,23 @@ def find_args(expr): _globals |= dtype_symbols evalcons = f"{constructor}({args})" + # Constructor results that read operands are values, not immutable + # plans. Rebuild them on each safe evaluation, even if metadata did not + # change. Constant-only constructors may keep their existing cache. + cacheable = evaluation_mode() == "full" or not parse_expression(evalcons).names + # Internal constructors will be cached for avoiding multiple computations if not hasattr(self, "cons_cache"): self.cons_cache = {} - if evalcons in self.cons_cache: - return self.cons_cache[evalcons], expression[idx:idx2] - value = eval(evalcons, _globals, operands) - self.cons_cache[evalcons] = value + if cacheable and evalcons in self.cons_cache: + value = self.cons_cache[evalcons] + if evaluation_mode() == "safe": + validate_operands({"constructor": value}) + return value, expression[idx:idx2] + _globals["blosc2"] = blosc2 + value = evaluate_expression(evalcons, _globals, operands) + if cacheable: + self.cons_cache[evalcons] = value return value, expression[idx:idx2] @@ -4559,6 +4729,46 @@ def _where_getitem_fastpath(self, item, kwargs): return indexing.evaluate_full_query(self._where_args, plan) def _compute_expr(self, item, kwargs): # noqa: C901 + output = kwargs.get("_output") + if ( + type(output) is np.ndarray + and output.dtype.kind == "c" + and type(item) is tuple + and not item + and not any(name in kwargs for name in ("_where_args", "_indices", "_order", "_reduce_args")) + ): + root = parse_expression(self.expression).root + if ( + root[0] == "call" + and root[1] == "complex" + and not root[3] + and all(node[0] == "name" for node in root[2]) + ): + casting = (kwargs.get("_ne_args") or {}).get("casting", "same_kind") + if not np.can_cast(np.dtype("complex128"), output.dtype, casting=casting): + raise TypeError("Cannot cast complex construction into destination") + return safe_numpy_globals["complex"]( + *(self.operands[node[1]] for node in root[2]), out=output + ) + if ( + ( + (type(output) is np.ndarray and not output.flags.c_contiguous) + or any(type(value) is np.ndarray and value.size == 0 for value in self.operands.values()) + ) + and (output is None or type(output) is np.ndarray) + and type(item) is tuple + and not item + and not any(name in kwargs for name in ("_where_args", "_indices", "_order", "_reduce_args")) + and all(type(value) is np.ndarray or np.isscalar(value) for value in self.operands.values()) + ): + # Layout is a destination contract, not a reason to select NumExpr. + # Until native sinks support strided writes, the approved NumPy graph + # supplies semantics; copyto preserves the caller's layout and identity. + result = parse_expression(self.expression).evaluate(self.operands, prefer_blosc=False) + if output is None: + return np.asarray(result) + np.copyto(output, result, casting=(kwargs.get("_ne_args") or {}).get("casting", "same_kind")) + return output if any(method in self.expression for method in eager_funcs): # We have reductions in the expression (probably coming from a string lazyexpr) # Also includes slice @@ -4584,7 +4794,7 @@ def _compute_expr(self, item, kwargs): # noqa: C901 # lazyexpr("mean(a + b)")[:10] means mean((a + b)[:10]). operands = _slice_operands_for_eager(operands, item) item = () - lazy_expr = eval(self.expression, _globals, operands) + lazy_expr = evaluate_expression(self.expression, _globals, operands) if not isinstance(lazy_expr, blosc2.LazyExpr): key, mask = process_key(item, lazy_expr.shape) # An immediate evaluation happened (e.g. all operands are numpy arrays) @@ -4602,7 +4812,7 @@ def _compute_expr(self, item, kwargs): # noqa: C901 out = kwargs.get("_output", None) if out is not None: # This is not exactly optimized, but it works for now - out[:] = lazy_expr[key] + out[...] = lazy_expr[key] return out arr = lazy_expr[key] if builtins.sum(mask) > 0: @@ -4633,8 +4843,8 @@ def _compute_expr(self, item, kwargs): # noqa: C901 newexpr = newexpr.replace(constexpr, newop) _globals = get_expr_globals(newexpr) - lazy_expr = eval(newexpr, _globals, newops) - if isinstance(lazy_expr, blosc2.NDArray): + lazy_expr = evaluate_expression(newexpr, _globals, newops) + if isinstance(lazy_expr, blosc2.NDArray | np.ndarray): # Almost done (probably the expression is made of only constructors) # We only have to define the trivial expression ("o0") lazy_expr = blosc2.LazyExpr(new_op=(lazy_expr, None, None)) @@ -4710,14 +4920,94 @@ def explain(self) -> dict: return indexing.explain_query(self) - def compute( + @expression_method + def compute( # noqa: C901 -- native-first/strict dispatch plus legacy output policies self, item=(), fp_accuracy: blosc2.FPAccuracy | None = None, jit=None, jit_backend: str | None = None, + _require_native=None, + _native_tile_items=1024, **kwargs, ) -> blosc2.NDArray: + self.__dict__.pop("_native_execution_report", None) + if _require_native: + from .native_graph import compute_native_graph + + if jit_backend is not None or fp_accuracy is not None: + raise ValueError( + "Native-required portable execution does not accept acceleration/accuracy overrides" + ) + return compute_native_graph(self, item, tile_items=_native_tile_items, jit=jit is True, **kwargs) + jit, jit_backend = _jit_from_env(jit, jit_backend) + if _require_native is None: + from .native_graph import ( + compute_native_graph, + compute_native_prefilter_if_eligible, + compute_resident_if_eligible, + prepare_native_first, + ) + + # Legacy chunked execution resolves inherited policy in its JIT + # decorator. Automatic dispatch must respect that same policy + # before choosing a route that cannot honor backend/accuracy + # overrides. Keep the original kwargs for legacy resolution. + policy = blosc2.jit_config.execution_options() + native_jit = policy["jit"] if jit is None else jit + native_backend = policy["jit_backend"] if jit_backend is None else jit_backend + native_accuracy = fp_accuracy + if native_accuracy is None and policy["fp_accuracy"] != blosc2.FPAccuracy.DEFAULT: + native_accuracy = policy["fp_accuracy"] + + resident = ( + compute_resident_if_eligible( + self, + item, + jit=native_jit, + jit_backend=native_backend, + fp_accuracy=native_accuracy, + options=kwargs, + ) + if _native_tile_items == 1024 + else None + ) + if resident is not None: + return resident + + stored = compute_native_prefilter_if_eligible( + self, + item, + jit=native_jit, + jit_backend=native_backend, + fp_accuracy=native_accuracy, + options=kwargs, + ) + if stored is not None: + return stored + + native_options = dict(kwargs) + if hasattr(self, "_output"): + native_options.setdefault("out", self._output) + if type(native_options.get("out")) is np.ndarray: + native_options["_getitem"] = True + + prepared = prepare_native_first( + self, + item, + jit=native_jit, + jit_backend=native_backend, + fp_accuracy=native_accuracy, + options=native_options, + ) + if prepared is not None: + return compute_native_graph( + self, + tile_items=_native_tile_items, + prepared=prepared, + parallel_reductions=True, + **native_options, + ) # When NumPy ufuncs are called, the user may add an `out` parameter to kwargs if "out" in kwargs: # use provided out preferentially kwargs["_output"] = kwargs.pop("out") @@ -4731,7 +5021,6 @@ def compute( if hasattr(self, "_where_args"): kwargs["_where_args"] = self._where_args kwargs.setdefault("fp_accuracy", fp_accuracy) - jit, jit_backend = _jit_from_env(jit, jit_backend) if jit is not None: kwargs["jit"] = jit if jit_backend is not None: @@ -4768,10 +5057,28 @@ def compute( result = blosc2.asarray(result, **kwargs) return result + def native_kernel(self): + """Export the eligible elementwise safe graph as an immutable native Menudet 1.0 plan. + + Unsupported syntax/signatures reject; no Python numerical fallback. Root + logical reduction options are separate from this elementwise artifact. + """ + from .native_graph import lower_native_graph + + plan, _, reduction = lower_native_graph(self) + if reduction: + raise ValueError("Root logical reductions require native compute, not an elementwise export") + return blosc2.PortableKernel.from_json(plan.map_json()) + def __getitem__(self, item): + safe = evaluation_mode() == "safe" or getattr(self, "_evaluation", "full") == "safe" + # Use admitted pre-read geometry for axis removal. A remote refresh may + # invalidate the handle after its read completed; do not re-enter that + # dependency merely to reshape the already independent result. + shape = self.shape if safe else None kwargs = {"_getitem": True} result = self.compute(item, **kwargs) - return _drop_indexed_axes(result, self.shape, item) + return _drop_indexed_axes(result, shape if safe else self.shape, item) def slice(self, item): return self.compute(item) # should do a slice since _getitem = False @@ -4817,15 +5124,24 @@ def save(self, urlpath=None, **kwargs): def to_cframe(self) -> bytes: return self._to_b2object_carrier().to_cframe() - def _to_b2object_carrier(self, **kwargs): + @expression_method + def _expression_recipe(self): expression = self.expression_tosave if hasattr(self, "expression_tosave") else self.expression operands_ = self.operands_tosave if hasattr(self, "operands_tosave") else self.operands validate_expr(expression) + return expression, operands_ + + def _to_b2object_carrier(self, **kwargs): + expression, operands_ = self._expression_recipe() + validate_expr(expression) payload = {"kind": "lazyexpr", "version": 1, "expression": expression, "operands": {}} carrier_urlpath = kwargs.get("urlpath") carrier_parent = Path(carrier_urlpath).parent if carrier_urlpath is not None else None for key, value in operands_.items(): + if type(value) is blosc2.NDField: + payload["operands"][key] = encode_operand_reference(value, base_path=carrier_parent) + continue if isinstance(value, blosc2.C2Array): payload["operands"][key] = encode_b2object_payload(value) continue @@ -4866,9 +5182,151 @@ def _to_b2object_carrier(self, **kwargs): return array @classmethod - def _new_expr(cls, expression, operands, guess, out=None, where=None, ne_args=None): - # Validate the expression - validate_expr(expression) + def _new_expr(cls, expression, operands, guess, out=None, where=None, ne_args=None): # noqa: C901 + native_metadata = ( + guess + and type(expression) is str + and type(operands) is dict + and operands + and out is None + and where is None + and ne_args is None + and evaluation_mode() == "full" + ) + text = _arithmetic_recipe_text(expression, operands) if native_metadata else None + if text is None or "#" in expression or _blacklist_re.search(expression): + validate_expr(expression) + if native_metadata: + from .native_graph import ( + _native_first_array, + _native_first_syntax, + _native_plan_cache_key, + ) + + if all(_native_first_array(value) for value in operands.values()): + graph = None + renamed = bindings = None + if text is None: + try: + graph = parse_expression(expression) + except (exceptions.UnsafeDeserializationError, ValueError): + graph = ( + None # Trusted expressions outside the reviewed grammar keep legacy preparation. + ) + if ( + graph is not None + and graph.names == operands.keys() + and (graph.arithmetic or _native_first_syntax(expression)) + ): + tree, nodes = expression_syntax(expression) + if ( + graph.root[0] == "binary" + and all(name.isascii() for name in graph.names) + and (graph.arithmetic or not any(isinstance(node, ast.Call) for node in nodes)) + ): + text = graph.text + else: + renamed, bindings = conserve_functions( + expression, operands, dict(operands), tree=tree + ) + if text is not None: + bindings, aliases = {}, {} + + def rebase(match): + name = match[0] + if name not in operands: + return name + value = operands[name] + key = aliases.get(id(value)) + if key is None: + key = aliases[id(value)] = f"o{len(bindings)}" + bindings[key] = value + return key + + # Canonical numeric text has no quoted strings or attribute names to rewrite. + renamed = _IDENTIFIER_RE.sub(rebase, text) + if renamed is not None: + root_kind = "binary" if text is not None else graph.root[0] + result = cls(None) + result.expression = f"({renamed})" + result.operands = bindings + result.expression_tosave = expression + result.operands_tosave = operands + result._ne_args = ne_args + result._evaluation = "full" + policy = blosc2.jit_config.execution_options() + native_jit, native_backend = _jit_from_env(policy["jit"], policy["jit_backend"]) + if ( + native_backend is None + and policy["fp_accuracy"] == blosc2.FPAccuracy.DEFAULT + and root_kind in {"binary", "unary", "compare"} + and not re.search(r"\bcopy\s*\(", expression) + ): + try: + from .graph_plan import NativeGraph + from .native_graph import native_weak_scalars_eligible, prepare_resident + + # The reviewed arithmetic subset can get metadata from its execution plan. + inputs = result.operands + resident = prepare_resident(result.expression, inputs, jit=native_jit) + if resident is not None: + result._resident_native = resident + _, plan, schedule = resident + info = {"dtype": plan.inferred_dtype, "shape": resident[0][2]} + else: + plan = NativeGraph.from_expression( + result.expression, + {name: value.dtype.name for name, value in inputs.items()}, + jit=native_jit, + ) + plan._frontend = "native-expression" + if not native_weak_scalars_eligible(plan, result.expression, inputs): + raise NotImplementedError( + "Checked scalar metadata requires legacy preparation" + ) + schedule = plan.specialize( + {name: (value.dtype, value.shape) for name, value in inputs.items()} + ) + info = schedule.info() + if plan.stages == 1 and info["dtype"].kind in "biuf": + result._dtype = info["dtype"] + result._shape = info["shape"] + key = _native_plan_cache_key( + result, + native_jit, + {"_getitem": True}, + configuration=None if resident is None else resident[0][-1][0], + ) + prepared = (key, (plan, tuple(inputs), False)) + if all(type(value) is np.ndarray for value in inputs.values()): + result._prepared_native = prepared + else: + # Compressed inputs must still pass execution/layout admission before reuse. + result._metadata_native = prepared + return result + except (NotImplementedError, blosc2.PortableArtifactError, TypeError, ValueError): + pass + if graph is None: + graph = parse_expression(expression) + shape = graph.infer_shape(operands) + dtype = graph.infer_dtype(operands) + if shape is not None and dtype is not None: + # Reviewed metadata avoids evaluating synthetic operands. + result._dtype = dtype + result._shape = shape + return result + graph_shape, graph_dtype = None, None + if evaluation_mode() == "safe": + graph = parse_expression(expression) + operands = normalize_operands(operands) + validate_operands(operands) + graph_shape = graph.infer_shape(operands) + graph_dtype = graph.infer_dtype(operands) + binding = graph.bind_root_reduction(operands) + if binding is not None: + normalized, root_shape, graph_dtype = binding + graph_shape = root_shape if root_shape is not None else graph_shape + expression = normalized or expression expression = convert_to_slice(expression) chunks, blocks = None, None if guess: @@ -4883,13 +5341,24 @@ def _new_expr(cls, expression, operands, guess, out=None, where=None, ne_args=No _operands[op] = blosc2.SimpleProxy(val) # for scalars just return value (internally converts to () if necessary) opshapes = {k: v if not hasattr(v, "shape") else v.shape for k, v in _operands.items()} - _shape = infer_shape(_expression, opshapes) # infer shape, includes constructors - # have to handle slices since a[10] on a dummy variable of shape (1,1) doesn't work - desliced_expr, desliced_ops = extract_and_replace_slices(_expression, _operands) + _shape = graph_shape if graph_shape is not None else infer_shape(_expression, opshapes) # substitutes with dummy operands (cheap for reductions) and # defaults to blosc2 functions (cheap for constructors) - new_expr = _numpy_eval_expr(desliced_expr, desliced_ops, prefer_blosc=True) - _dtype = new_expr.dtype if hasattr(new_expr, "dtype") else np.dtype(type(new_expr)) + if graph_shape is not None and graph_dtype is not None: + # Data-free graph rules supplied metadata. Do not + # execute that reduction on all-one dummies (ddof may exceed + # their size even when the real input is perfectly valid). + new_expr = np.empty((), dtype=graph_dtype) + else: + # Handle slices before dummy evaluation: a[10] cannot index a + # synthetic array of shape (1, 1). + desliced_expr, desliced_ops = extract_and_replace_slices(_expression, _operands) + new_expr = _numpy_eval_expr(desliced_expr, desliced_ops, prefer_blosc=True) + _dtype = ( + graph_dtype + if graph_dtype is not None + else (new_expr.dtype if hasattr(new_expr, "dtype") else np.dtype(type(new_expr))) + ) if isinstance(new_expr, blosc2.LazyExpr): # DO NOT restore the original expression and operands # Instead rebase operands and restore only constructors @@ -4910,6 +5379,7 @@ def _new_expr(cls, expression, operands, guess, out=None, where=None, ne_args=No chunks = new_expr.chunks blocks = new_expr.blocks new_expr = cls(None) + new_expr._evaluation = evaluation_mode() new_expr.expression = f"({expression_})" # force parenthesis new_expr.operands = operands_ new_expr.expression_tosave = expression @@ -4929,6 +5399,9 @@ def _new_expr(cls, expression, operands, guess, out=None, where=None, ne_args=No if where is not None: new_expr._where_args = where new_expr._ne_args = ne_args + new_expr._evaluation = evaluation_mode() + if evaluation_mode() == "safe": + record_expression_metadata(new_expr) return new_expr @@ -5092,6 +5565,10 @@ def __init__( def dtype(self): return self._dtype + @property + def nbytes(self): + return math.prod(self.shape) * np.dtype(self.dtype).itemsize + @property def ndim(self) -> int: return len(self.shape) @@ -5257,9 +5734,19 @@ def compute( aux_kwargs.update(kwargs) # aux_kwargs includes self.shape and self.dtype + from .dsl_execution import evaluate_dsl_udf + + handled, result = evaluate_dsl_udf(self, item, getitem=False, options=aux_kwargs) + if handled: + return result return chunked_eval(self.func, self.inputs_dict, item, _getitem=False, **aux_kwargs) def __getitem__(self, item): + from .dsl_execution import evaluate_dsl_udf + + handled, result = evaluate_dsl_udf(self, item, getitem=True, options=self.kwargs) + if handled: + return result result = chunked_eval(self.func, self.inputs_dict, item, _getitem=True, **self.kwargs) return _drop_indexed_axes(result, self.shape, item) @@ -5282,65 +5769,20 @@ def save(self, urlpath=None, **kwargs): ----- * All operands must be :ref:`NDArray` or :ref:`C2Array` objects stored on disk or a remote server (i.e. they must have a ``urlpath``). - * When the :ref:`LazyUDF` wraps a :func:`blosc2.dsl_kernel`-decorated - function, the DSL source is preserved verbatim in the saved metadata. - On reload via :func:`blosc2.open`, the function is restored as a full - :class:`~blosc2.dsl_kernel.DSLKernel` so the miniexpr JIT fast path - remains available without any extra work from the caller. + * Newly authored DSLKernel functions normalize and validate as portable + 1.0 before saving. Python UDFs and noncompliant kernels reject before + writing. Block-scalar kernels require the explicit portable API. + Historical source-backed files require ``deserialize='full'`` on open + and are not automatically migrated by saving. """ if urlpath is None: raise ValueError("To save a LazyArray you must provide an urlpath") - kwargs["urlpath"] = urlpath - kwargs["mode"] = "w" # always overwrite the file in urlpath - try: - self._to_b2object_carrier(**kwargs) - except (TypeError, ValueError): - meta = kwargs.get("meta", {}) - meta["LazyArray"] = LazyArrayEnum.UDF.value - kwargs["meta"] = meta - - # Create an empty array; useful for providing the shape and dtype of the outcome - array = blosc2.empty(shape=self.shape, dtype=self.dtype, **kwargs) + from blosc2.portable_lazy import portable_from_lazyudf - # Save the expression and operands in the metadata - operands = {} - operands_ = self.inputs_dict - for i, (_key, value) in enumerate(operands_.items()): - pos_key = f"o{i}" # always use positional keys for consistent loading - if isinstance(value, blosc2.C2Array): - operands[pos_key] = { - "path": str(value.path), - "urlbase": value.urlbase, - } - continue - if isinstance(value, blosc2.Proxy): - # Take the required info from the Proxy._cache container - value = value._cache - if not hasattr(value, "schunk"): - raise ValueError( - "To save a LazyArray, all operands must be blosc2.NDArray or blosc2.C2Array objects" - ) from None - if value.schunk.urlpath is None: - raise ValueError( - "To save a LazyArray, all operands must be stored on disk/network" - ) from None - operands[pos_key] = value.schunk.urlpath - udf_func = self.func.func if isinstance(self.func, DSLKernel) else self.func - udf_name = getattr(udf_func, "__name__", self.func.__name__) - try: - udf_source = textwrap.dedent(inspect.getsource(udf_func)).lstrip() - except Exception: - udf_source = None - meta = { - "UDF": udf_source, - "operands": operands, - "name": udf_name, - } - if isinstance(self.func, DSLKernel) and self.func.dsl_source is not None: - meta["dsl_source"] = self.func.dsl_source - array.schunk.vlmeta["_LazyArray"] = meta - write_b2object_user_vlmeta(array, self._get_user_vlmeta()) + portable = portable_from_lazyudf(self) + portable.save(urlpath, **kwargs) + self.array, self.schunk = portable.array, portable.schunk def to_cframe(self) -> bytes: return self._to_b2object_carrier().to_cframe() @@ -5367,8 +5809,12 @@ def _to_b2object_carrier(self, **kwargs): ref_urlpath = operand_urlpath.as_posix() operand_payload["urlpath"] = ref_urlpath + from blosc2.msgpack_utils import msgpack_packb + + msgpack_packb(payload) + msgpack_packb(self._get_user_vlmeta()) array = make_b2object_carrier( - "lazyudf", + "portable", self.shape, self.dtype, chunks=self.chunks, @@ -5410,13 +5856,20 @@ def _numpy_eval_expr(expression, operands, prefer_blosc=False): if prefer_blosc: _globals = get_expr_globals(expression) _globals |= dtype_symbols + if all(type(value) is np.ndarray or np.isscalar(value) for value in ops.values()): + # Blosc2's bare where/copy expect lazy or stored receivers, while + # these synthetic operands represent ordinary resident NumPy values. + _globals.update(where=np.where, copy=np.copy) else: _globals = safe_numpy_globals try: - _out = _numpy_eval_datetime_aware(expression, _globals, ops) + # Dummy values are only for shape/dtype inference. Their artificial + # domain boundaries must not emit diagnostics for the actual operands. + with np.errstate(all="ignore"): + _out = _numpy_eval_datetime_aware(expression, _globals, ops) except RuntimeWarning: # Sometimes, numpy gets a RuntimeWarning when evaluating expressions - # with synthetic operands (1's). Let's try with numexpr, which is not so picky + # with synthetic operands (1's). Try the native/NumPy chunk evaluator. # about this. ops = npops if blosc2.IS_WASM else ops _out = ne_evaluate(expression, local_dict=ops) @@ -5589,6 +6042,8 @@ def lazyexpr( global_dict: dict | None = None, ne_args: dict | None = None, _frame_depth: int = 2, + *, + evaluation: str | None = None, ) -> LazyExpr: """ Get a LazyExpr from an expression. @@ -5596,8 +6051,8 @@ def lazyexpr( Parameters ---------- expression: str or bytes or LazyExpr or NDArray - The expression to evaluate. This can be any valid expression that numexpr - can ingest. If a LazyExpr is passed, the expression will be + The expression to evaluate, using supported numerical and array operations. + If a LazyExpr is passed, the expression will be updated with the new operands. operands: dict[blosc2.Array], optional The dictionary with operands. Supported values are Python scalars, @@ -5606,6 +6061,10 @@ def lazyexpr( out: blosc2.Array, optional The output array where the result will be stored. If not provided, a new NumPy array will be created and returned. + Eligible one-dimensional compressed inputs use the miniexpr prefilter + to write directly into this new NumPy allocation, without storing an + intermediate Blosc2 result. A supplied NumPy output uses bounded chunk + scratch instead. Other layouts retain the regular evaluation paths. where: tuple, list, optional A sequence of arguments for the where clause in the expression. local_dict: dict, optional @@ -5615,7 +6074,7 @@ def lazyexpr( The global dictionary to use when looking for operands in the expression. If not provided, the global dictionary of the caller will be used. ne_args: dict, optional - Additional arguments to be passed to `numexpr.evaluate()` function. + Compatibility expression options, validated independently of backend. _frame_depth: int, optional The depth of the frame to use when looking for operands in the expression. The default value is 2. @@ -5651,6 +6110,20 @@ def lazyexpr( [ 5.515625 8.25 11.765625] [16.0625 21.140625 27. ]] """ + if evaluation is not None: + with expression_evaluation(evaluation): + return lazyexpr( + expression, + operands, + out, + where, + local_dict, + global_dict, + ne_args, + _frame_depth=_frame_depth + 1, + ) + if isinstance(expression, str) and evaluation_mode() == "safe": + parse_expression(expression) if operands is not None and isinstance(expression, str): # A UTF8Array is variable-width, so it cannot be an expression operand. # It only duck-types as one: LazyExpr would wrap it in a SimpleProxy, @@ -5692,7 +6165,9 @@ def lazyexpr( else: # No operands found in the expression. Maybe a constructor? constructor = any(_has_constructor_call(expression, constructor) for constructor in constructors) - if not constructor: + if not constructor and parse_expression(expression).names: + # Approved constant-only numerical expressions are valid too; + # parsing, rather than Python eval, decides whether to admit them. raise ValueError("No operands nor constructors found in the expression") # _new_expr will take care of the constructor, but needs an empty dict in operands operands = {} @@ -5738,6 +6213,12 @@ def _reconstruct_lazyudf(expr, lazyarray, operands_dict, array): def open_lazyarray(array): + from blosc2.deserialization import DeserializeMode, get_deserialize + from blosc2.exceptions import UnsafeDeserializationError + + policy = get_deserialize(array) + if policy is not DeserializeMode.FULL: + raise UnsafeDeserializationError("legacy LazyArray") value = array.schunk.meta["LazyArray"] lazyarray = array.schunk.vlmeta["_LazyArray"] if value == LazyArrayEnum.Expr.value: @@ -5755,7 +6236,7 @@ def open_lazyarray(array): if isinstance(v, str): v = parent_path / v try: - op = blosc2.open(v, mode="r") + op = blosc2.open(v, mode="r", deserialize=policy) except FileNotFoundError: missing_ops[key] = v else: @@ -5780,6 +6261,7 @@ def open_lazyarray(array): new_expr = LazyExpr._new_expr(expr, operands_dict, guess=True, out=None, where=None) elif value == LazyArrayEnum.UDF.value: new_expr = _reconstruct_lazyudf(expr, lazyarray, operands_dict, array) + new_expr._legacy_source_recipe = True # Make the array info available for the user (only available when opened from disk) new_expr.array = array @@ -5789,7 +6271,244 @@ def open_lazyarray(array): return new_expr -# Mimim numexpr's evaluate function +# NumExpr-style convenience interface with backend-independent contracts. +@dataclass(frozen=True, slots=True) +class _EvaluateRecipe: + """Operand-free construction metadata and optional immutable resident schedule.""" + + expression: str + bindings: tuple + dtype: np.dtype + shape: tuple + chunks: tuple | None + blocks: tuple | None + resident: tuple | None = None + + +_evaluate_recipe_cache = OrderedDict() +_evaluate_recipe_lock = threading.Lock() +_EVALUATE_RECIPE_CACHE_SIZE = 128 + + +@lru_cache(maxsize=128) +def _evaluate_recipe_names(expression): + """Restrict caching to reviewed elementwise syntax with literal constants.""" + if type(expression) is not str: + return None + names = arithmetic_names(expression) + if names is not None: + return names or None + try: + graph = parse_expression(expression) + if graph.arithmetic: + return tuple(sorted(graph.names)) or None + tree, nodes = expression_syntax(expression) + except (exceptions.UnsafeDeserializationError, ValueError, SyntaxError): + return None + allowed = ( + ast.Expression, + ast.Name, + ast.Load, + ast.Constant, + ast.BinOp, + ast.UnaryOp, + ast.Compare, + ast.Add, + ast.Sub, + ast.Mult, + ast.Div, + ast.FloorDiv, + ast.Mod, + ast.Pow, + ast.LShift, + ast.RShift, + ast.UAdd, + ast.USub, + ast.Invert, + ast.BitAnd, + ast.BitOr, + ast.BitXor, + ast.Eq, + ast.NotEq, + ast.Lt, + ast.LtE, + ast.Gt, + ast.GtE, + ) + from .native_graph import NATIVE_ELEMENTWISE_CALLS, REDUCERS + + calls = { + **NATIVE_ELEMENTWISE_CALLS, + **dict.fromkeys(REDUCERS, 1), + "complex": 2, + "ones_like": 1, + "contains": 2, + } + for node in nodes: + if isinstance(node, ast.Call): + if ( + not isinstance(node.func, ast.Name) + or node.func.id not in calls + or node.keywords + or len(node.args) != calls[node.func.id] + ): + return None + elif not isinstance(node, allowed): + return None + return tuple(sorted(graph.names)) or None + + +def _prepare_cached_evaluate(expression, local_dict, global_dict): + if type(expression) is not str or len(expression) > 65536: + return None + names = _evaluate_recipe_names(expression) + if names is None: + return None + # seek_operands -> this helper -> evaluate -> user; preserve evaluate's + # ordinary caller-local/global resolution, including explicitly supplied dicts. + inputs = seek_operands(names, local_dict, global_dict, _frame_depth=3) + if any( + type(value) not in (np.ndarray, blosc2.NDArray) + or value.dtype.kind not in "biufcS" + or not value.dtype.isnative + or value.dtype.metadata is not None + for value in inputs.values() + ) or len({id(value) for value in inputs.values()}) != len(inputs): + # Avoid ambiguous alias-to-name mappings and scalar capture semantics. + return lazyexpr(expression, operands=inputs, ne_args=None) + validate_operands(inputs) + mode = evaluation_mode() + signature = tuple( + ( + name, + type(value), + value.dtype, + tuple(value.shape), + value.chunks if type(value) is blosc2.NDArray else None, + value.blocks if type(value) is blosc2.NDArray else None, + ) + for name, value in inputs.items() + ) + key = (expression, signature, mode) + with _evaluate_recipe_lock: + recipe = _evaluate_recipe_cache.get(key) + if recipe is not None: + _evaluate_recipe_cache.move_to_end(key) + from .native_graph import prepare_resident + + policy = blosc2.jit_config.execution_options() + native_jit, native_backend = _jit_from_env(policy["jit"], policy["jit_backend"]) + resident = ( + prepare_resident( + expression, + inputs, + jit=native_jit, + cached=recipe.resident if recipe is not None else None, + ) + if native_backend is None and policy["fp_accuracy"] == blosc2.FPAccuracy.DEFAULT + else None + ) + if resident is not None and (recipe is None or resident is not recipe.resident): + # Division, comparisons and mixed inputs can produce a different dtype from every operand. + info = resident[2].info() + recipe = _EvaluateRecipe( + expression, + tuple((name, name) for name in inputs), + info["dtype"], + info["shape"], + None, + None, + resident, + ) + with _evaluate_recipe_lock: + _evaluate_recipe_cache[key] = recipe + _evaluate_recipe_cache.move_to_end(key) + while len(_evaluate_recipe_cache) > _EVALUATE_RECIPE_CACHE_SIZE: + _evaluate_recipe_cache.popitem(last=False) + elif recipe is None: + expr = lazyexpr(expression, operands=inputs, ne_args=None) + # Match constructor-renamed bindings to original names without retaining + # arrays in either the cache key or recipe. Aliased inputs were excluded. + source_names = {id(value): name for name, value in inputs.items()} + if any(id(value) not in source_names for value in expr.operands.values()): + return expr + recipe = _EvaluateRecipe( + expr.expression, + tuple((name, source_names[id(value)]) for name, value in expr.operands.items()), + np.dtype(expr.dtype), + tuple(expr.shape), + tuple(expr._chunks) if hasattr(expr, "_chunks") else None, + tuple(expr._blocks) if hasattr(expr, "_blocks") else None, + ) + with _evaluate_recipe_lock: + _evaluate_recipe_cache[key] = recipe + _evaluate_recipe_cache.move_to_end(key) + while len(_evaluate_recipe_cache) > _EVALUATE_RECIPE_CACHE_SIZE: + _evaluate_recipe_cache.popitem(last=False) + return expr + if resident is not None: + return resident, inputs + expr = LazyExpr(None) + expr.expression = recipe.expression + expr.operands = {name: inputs[source] for name, source in recipe.bindings} + expr.expression_tosave = expression + expr.operands_tosave = dict(inputs) + expr._dtype, expr._shape = recipe.dtype, recipe.shape + if recipe.chunks is not None: + expr._chunks, expr._blocks = recipe.chunks, recipe.blocks + expr._ne_args = None + expr._evaluation = mode + if mode == "safe": + record_expression_metadata(expr) + return expr + + +def validate_evaluate_options(options): + """Validate public options before choosing a numerical backend.""" + unknown = options.keys() - {"order", "casting", "optimization"} + if unknown: + raise ValueError(f"Unknown keyword argument {sorted(unknown)[0]!r}") + order = options.get("order", "K") + if not isinstance(order, str) or order.upper() not in {"C", "F", "A", "K"}: + raise ValueError("order must be one of 'C', 'F', 'A', or 'K'") + if options.get("optimization", "aggressive") not in ("none", "moderate", "aggressive"): + raise ValueError("optimization must be 'none', 'moderate', or 'aggressive'") + # Ask NumPy to validate the casting spelling even when no output was supplied. + np.can_cast(np.dtype("float64"), np.dtype("float64"), casting=options.get("casting", "same_kind")) + + +def _evaluate_ordered_output(expr, order): + """Allocate using NumPy's broadcast iteration order without reading operands.""" + arrays = [value for value in expr.operands.values() if type(value) is np.ndarray] + if order == "C" or not arrays: + return np.empty(expr.shape, dtype=expr.dtype, order="F" if order == "F" else "C") + try: + broadcast_shape = np.broadcast_shapes(*(value.shape for value in arrays)) + except ValueError: + broadcast_shape = None # Reduced intermediates may broadcast even when inputs do not. + if broadcast_shape == expr.shape: + with np.nditer( + [*arrays, None], + flags=["zerosize_ok", "refs_ok"], + op_flags=[["readonly"] for _ in arrays] + [["writeonly", "allocate"]], + op_dtypes=[None for _ in arrays] + [expr.dtype], + order=order, + ) as iterator: + return iterator.operands[-1] + # Reductions/shape-changing expressions do not share the input iteration domain. + fortran = order == "F" or (order in {"A", "K"} and all(a.flags.f_contiguous for a in arrays)) + return np.empty(expr.shape, dtype=expr.dtype, order="F" if fortran else "C") + + +def _array_owner(value): + while True: + base = value.obj if isinstance(value, memoryview) else getattr(value, "base", None) + if base is None: + return value + value = base + + +@remember_evaluation def evaluate( ex: str, local_dict: dict | None = None, @@ -5800,16 +6519,39 @@ def evaluate( """ Evaluate a string expression using the Blosc2 compute engine. - This is a drop-in replacement for `numexpr.evaluate()`, but using the - Blosc2 compute engine. This allows for: + This provides a NumExpr-style expression interface using native miniexpr + execution and explicit NumPy fallbacks, without importing NumExpr. It allows: - 1) Use more functionality (e.g. reductions) than numexpr. + 1) Use additional NumPy/Blosc2 expression functionality. 2) Follow casting rules of NumPy more closely. 3) Use both NumPy arrays and Blosc2 NDArrays in the same expression. As NDArrays can be on-disk, the expression can be evaluated without loading the whole array into memory (i.e. using an out-of-core approach). + Repeated array-only reviewed arithmetic, math and reduction expressions + without extra options reuse a bounded, operand-free preparation recipe. + Current inputs and any supplied output are rebound on every call; otherwise + a fresh NumPy output is allocated. Neither operand/output arrays nor numerical + results are retained in the cache. + + Aligned C-contiguous native numeric maps with matching operand shapes bind + directly to immutable native schedules, avoiding general lazy/storage dispatch. + Large partitionable maps retain parallel execution with the current thread count. + + Eligible numeric arithmetic and elementwise math calls use the native + Menudet kernels, including explicit NumPy or Blosc2 destinations. Compressed + destinations retain bounded input tiles; matching floating storage grids use + the compression prefilter. Unsupported signatures, aliasing and explicit + backend/accuracy policies retain the existing dispatch rules. + + Eligible expressions default to native interpretation through the shared + native structural policy (single-return expression versus program), also used + by Menudet kernels and graph-generated maps. Explicit JIT settings from + :func:`blosc2.set_jit_options`, :func:`blosc2.jit_options` or ``ME_DSL_JIT`` + retain their existing precedence. For example, use + ``with blosc2.jit_options(jit=True):`` to opt into best-effort JIT execution. + Parameters ---------- ex: str @@ -5824,7 +6566,22 @@ def evaluate( The output array where the result will be stored. If not provided, a new NumPy array will be created and returned. kwargs: Any, optional - Additional arguments to be passed to `numexpr.evaluate()` function. + Accepted options are ``order``, ``casting`` and ``optimization``. + ``optimization`` defaults to ``"aggressive"`` and is accepted as a hint; + no NumExpr algebraic transformations or relaxed math policies are applied. + ``casting`` defaults to ``"same_kind"`` and controls conversion into an + explicit destination, not arithmetic precision. + ``order`` controls newly allocated NumPy output: ``"C"`` or ``"F"`` + requests contiguous row-major or column-major storage, ``"A"`` follows + Fortran-contiguous operands when possible, and ``"K"`` (default) + follows operand iteration order. An explicit output retains its layout + and identity, including when it is empty. Blosc2 consumes ``order`` as + an allocation policy; it is not forwarded to NumExpr. Resident strided + outputs use native destination descriptors when supported. Unsupported + operations use an explicit NumPy fallback. + The legacy ``truediv``, ``sanitize`` and ``disable_cache`` options are no + longer accepted. Division follows NumPy semantics, validation follows + the expression evaluation policy, and preparation caches are automatic. Returns ------- @@ -5848,12 +6605,78 @@ def evaluate( [ 5.515625 8.25 11.765625] [16.0625 21.140625 27. ]] """ - lexpr = lazyexpr( - ex, local_dict=local_dict, global_dict=global_dict, out=out, ne_args=kwargs, _frame_depth=3 - ) + if kwargs: + validate_evaluate_options(kwargs) + # The optimization hint has no backend-specific numerical transformation. + # Consume it here rather than blocking native/JIT admission accidentally. + kwargs.pop("optimization", None) + order = kwargs.pop("order", "K") + order = order.upper() + lexpr = _prepare_cached_evaluate(ex, local_dict, global_dict) if not kwargs else None + if isinstance(lexpr, tuple): + resident, inputs = lexpr + if out is None and order in {"C", "A", "K"}: + from .native_graph import execute_resident + + # Admission and policy were resolved for these current arrays; execution never falls back. + return execute_resident(resident, inputs)[0] + # Layout/casting/storage requests retain the public output preflight and the same native plan. + lexpr = LazyExpr(None) + lexpr.expression = ex + lexpr.operands = inputs + lexpr.expression_tosave, lexpr.operands_tosave = ex, dict(inputs) + info = resident[2].info() + lexpr._dtype, lexpr._shape = info["dtype"], info["shape"] + lexpr._ne_args, lexpr._evaluation = None, evaluation_mode() + lexpr._resident_native = resident + if lexpr._evaluation == "safe": + record_expression_metadata(lexpr) + if lexpr is None: + lexpr = lazyexpr( + ex, + local_dict=local_dict, + global_dict=global_dict, + out=out, + ne_args=kwargs or None, + _frame_depth=3, + ) + if out is None and ( + order == "F" + or ( + order in {"A", "K"} + and any( + type(value) is np.ndarray and not value.flags.c_contiguous + for value in lexpr.operands.values() + ) + ) + ): + out = _evaluate_ordered_output(lexpr, order) if out is not None: + if type(out) is np.ndarray: + if not out.flags.writeable: + raise ValueError("output array is read-only") + casting = kwargs.get("casting", "same_kind") + if not np.can_cast(lexpr.dtype, out.dtype, casting=casting): + raise TypeError( + f"Cannot cast result from {lexpr.dtype} to {out.dtype} with casting={casting!r}" + ) + if np.broadcast_shapes(lexpr.shape, out.shape) != out.shape: + raise ValueError("output shape cannot hold the expression result") + # Snapshot overlapping inputs before any writes, including shifted + # views. NumExpr's copy opcode itself is not overlap-safe. + lexpr.operands = { + name: value.copy() + if type(value) is np.ndarray + and (_array_owner(value) is _array_owner(out) or np.shares_memory(value, out)) + else value + for name, value in lexpr.operands.items() + } + lexpr._output = out # The user specified an output array - return lexpr.compute() + result = lexpr.compute() + if type(out) is np.ndarray and out.size == 0 and np.shape(result) == out.shape: + return out + return result # The user did not specify an output array, so return a NumPy array return lexpr[()] @@ -5881,7 +6704,7 @@ def evaluate( print(f"Elapsed time (numpy, [:]): {time() - t0:.3f} s") t0 = time() nres = ne_evaluate("na1 + na2") - print(f"Elapsed time (numexpr, [:]): {time() - t0:.3f} s") + print(f"Elapsed time (native/NumPy, [:]): {time() - t0:.3f} s") nres = nres[sl] if sl is not None else nres t0 = time() res = expr.compute(item=sl) @@ -5904,7 +6727,7 @@ def evaluate( print(f"Elapsed time (numpy, [:]): {time() - t0:.3f} s") t0 = time() nres = ne_evaluate("tan(na1) * (sin(na2) * sin(na2) + cos(na3)) + (sqrt(na4) * 2) + 2") - print(f"Elapsed time (numexpr, [:]): {time() - t0:.3f} s") + print(f"Elapsed time (native/NumPy, [:]): {time() - t0:.3f} s") nres = nres[sl] if sl is not None else nres t0 = time() res = expr.compute(sl) diff --git a/src/blosc2/menudet.py b/src/blosc2/menudet.py new file mode 100644 index 000000000..a138962ae --- /dev/null +++ b/src/blosc2/menudet.py @@ -0,0 +1,286 @@ +"""Annotated or call-time-specialized Menudet functions with no Python fallback.""" + +from __future__ import annotations + +import ast +import functools +import inspect +import os +from threading import RLock +from types import CellType, FunctionType + +import numpy as np + +from .dsl_kernel import DSLKernel +from .portable_kernel import capture_analysis, portable_dtype_descriptor, prepare_portable_kernel + + +def _dtype(annotation): + if annotation is None: + raise TypeError("Unsupported Menudet dtype annotation: None") + try: + dtype = np.dtype(annotation) + portable_dtype_descriptor(dtype) + except (TypeError, ValueError) as error: + raise TypeError(f"Unsupported Menudet dtype annotation: {annotation!r}") from error + return dtype.newbyteorder("=") + + +class MenudetKernel: + """Callable Menudet author; dtype specializations own portable native kernels. + + Calls bind arrays and return a lazy result. Annotations specify element dtypes, + not array shapes. Missing input annotations use array dtypes; missing output + annotations use native numeric result inference, never Python execution. + Scalar captures are snapshotted at decoration; array values are never cached. + """ + + def __init__( + self, + func, + *, + jit=None, + require_jit=False, + partitions=None, + cardinality="elementwise", + ndim=0, + casting="unsafe", + ): + if not inspect.isfunction(func): + raise TypeError("@menudet requires an ordinary Python function") + if (jit is not None and type(jit) is not bool) or type(require_jit) is not bool: + raise TypeError("jit must be bool or None; require_jit must be bool") + if require_jit and jit is False: + raise ValueError("require_jit=True conflicts with jit=False") + self._signature = inspect.signature(func) + if any( + p.kind not in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD) + for p in self._signature.parameters.values() + ): + raise TypeError( + "Menudet functions require positional parameters; no *args/**kwargs/keyword-only args" + ) + annotations = inspect.get_annotations(func, eval_str=True) + self._parameters = self._signature.parameters + self._names = tuple(self._parameters) + self._positional_only = frozenset( + name + for name, parameter in self._parameters.items() + if parameter.kind is parameter.POSITIONAL_ONLY + ) + self._defaults = { + name: parameter.default + for name, parameter in self._parameters.items() + if parameter.default is not parameter.empty + } + self._input_dtypes = { + name: _dtype(annotations[name]) for name in self._signature.parameters if name in annotations + } + self._output_dtype = _dtype(annotations["return"]) if "return" in annotations else None + author = DSLKernel(func) + if author.dsl_error is not None: + raise author.dsl_error + if author.row_columns is not None: + raise TypeError("Menudet decorators currently accept array parameters, not row proxies") + # Annotations/defaults are Python binding metadata, not native syntax or + # captures. Normalize only this author's header; leave @dsl_kernel intact. + tree = ast.parse(author.dsl_source) + function = tree.body[0] + function.returns = None + function.args.defaults = [] + function.args.posonlyargs, function.args.args = [], function.args.posonlyargs + function.args.args + for arg in function.args.args: + arg.annotation = None + author.dsl_source = ast.unparse(tree) + # Export capture lookup must not observe later global/closure rebinding. + closure = tuple(CellType(cell.cell_contents) for cell in func.__closure__ or ()) or None + author.func = FunctionType( + func.__code__, func.__globals__.copy(), func.__name__, func.__defaults__, closure + ) + # Source structure is fixed; capture values and native validation retain their usual timing. + author._capture_analysis = capture_analysis(author.dsl_source, author.input_names) + self._expression = None + if ( + len(function.body) == 1 + and isinstance(function.body[0], ast.Return) + and function.body[0].value is not None + ): + from .expression_graph import arithmetic_names + + expression = ast.unparse(function.body[0].value) + if arithmetic_names(expression) == tuple(sorted(self._names)): + self._expression = expression + self._author = author + self._jit, self._require_jit = jit, require_jit + self._partitions = tuple(partitions) if partitions is not None else None + self._export_options = {"cardinality": cardinality, "ndim": ndim, "casting": casting} + self._kernels = {} + self._lock = RLock() + functools.update_wrapper(self, func, updated=()) + + def _bind(self, args, kwargs): + import blosc2 + + names = self._names + if len(args) > len(names): + raise TypeError("too many positional arguments") + supplied = dict(zip(names, args, strict=False)) + for name, value in kwargs.items(): + if name not in self._parameters or name in self._positional_only: + raise TypeError(f"got an unexpected keyword argument {name!r}") + if name in supplied: + raise TypeError(f"multiple values for argument {name!r}") + supplied[name] = value + inputs = {} + for name in names: + try: + value = supplied[name] + except KeyError: + if name not in self._defaults: + raise TypeError(f"missing a required argument: {name!r}") from None + value = self._defaults[name] + if type(value) not in (np.ndarray, blosc2.NDArray): + if name not in self._input_dtypes or not np.isscalar(value): + raise TypeError(f"{name}: unannotated inputs must be NumPy or Blosc2 arrays") + value = np.asarray(value) + actual = np.dtype(value.dtype).newbyteorder("=") + declared = self._input_dtypes.get(name) + if declared is not None and actual != declared: + raise TypeError(f"{name}: expected dtype {declared}, got {actual}; cast explicitly") + portable_dtype_descriptor(actual) + inputs[name] = value + return inputs + + def _specialize(self, inputs): + from . import FPAccuracy, jit_config + + dtypes = {name: np.dtype(value.dtype).newbyteorder("=") for name, value in inputs.items()} + options = jit_config.execution_options() + key = ( + tuple((name, dtype.str) for name, dtype in dtypes.items()), + tuple(options.items()), + tuple( + (name, os.environ.get(name)) + for name in ( + "ME_DSL_JIT", + "BLOSC_ME_JIT", + "ME_DSL_JIT_COMPILER", + "ME_SIMD_MATH_BACKEND", + "ME_DSL_FP_MODE", + "CC", + "CFLAGS", + "ME_DSL_JIT_TCC_OPTIONS", + "ME_DSL_JIT_LIBTCC_PATH", + ) + ), + ) + with self._lock: + if key not in self._kernels: + output = self._output_dtype + jit = True if self._require_jit else self._jit + policy = options["jit"] if jit is None else jit + if policy is None and os.environ.get("BLOSC_ME_JIT", "").lower() in ( + "1", + "true", + "on", + "tcc", + "cc", + ): + policy = True + compiled = policy is True or ( + policy is None + and os.environ.get("ME_DSL_JIT", "").lower() not in ("", "0", "false", "off") + ) + configured = any( + options[name] + for name in ("compiler", "cflags", "trace", "compiler_output", "jit_backend") + ) or (compiled and options["cache_dir"] is not None) + kernel = None + if ( + output is None + and self._expression is not None + and self._export_options["cardinality"] == "elementwise" + and self._export_options["ndim"] == 0 + and self._export_options["casting"] == "unsafe" + and not configured + and options["fp_accuracy"] == FPAccuracy.DEFAULT + and all(dtype.kind in "biuf" for dtype in dtypes.values()) + ): + from .graph_plan import NativeGraph + from .native_graph import resident_map_kernel + from .portable_kernel import PortableArtifactError + + try: + plan = NativeGraph.from_expression( + self._expression, dtypes, jit=policy, require_jit=self._require_jit + ) + kernel = resident_map_kernel(plan) + except (NotImplementedError, PortableArtifactError, TypeError, ValueError): + pass + if kernel is not None: + kernel._resident_plan = plan + kernel._resident_expression = self._expression + if kernel.inferred_dtype is None: + raise TypeError( + "Native output inference is unavailable; add a return dtype annotation" + ) + if kernel is not None: + self._kernels[key] = kernel + return kernel + if output is None: + if any(dtype.kind not in "biuf" for dtype in dtypes.values()): + raise TypeError("Nonnumeric kernels require a return dtype annotation") + kernel = prepare_portable_kernel( + self._author, dtypes, None, jit=jit, **self._export_options + ) + else: + kernel = prepare_portable_kernel( + self._author, dtypes, output, jit=jit, **self._export_options + ) + if self._require_jit and not kernel.has_jit: + raise RuntimeError("Required Menudet JIT is unavailable for this signature") + self._kernels[key] = kernel + return self._kernels[key] + + def specialize(self, *args, **kwargs): + """Return the cached PortableKernel for these arguments without evaluating them.""" + return self._specialize(self._bind(args, kwargs)) + + def __call__(self, *args, **kwargs): + inputs = self._bind(args, kwargs) + return self._specialize(inputs).lazy(inputs, partitions=self._partitions) + + +def menudet( + func=None, + *, + jit=None, + require_jit=False, + partitions=None, + cardinality="elementwise", + ndim=0, + casting="unsafe", +): + """Decorate a function as a lazy, typed Menudet kernel (JIT preferred by default). + + Use ``@menudet`` or ``@menudet(jit=False)``. Supported dtype annotations + declare element types; unannotated NumPy/Blosc2 arrays supply their dtypes. + Annotated inputs must match exactly, without implicit casts. Numeric return + inference uses native metadata. Scalar arguments require dtype annotations. + Native interpreter fallback is allowed unless ``require_jit=True``; the + original Python function is never executed, including after native errors. + ``partitions`` and ``cardinality`` retain PortableKernel.lazy block semantics. + """ + + def decorate(function): + return MenudetKernel( + function, + jit=jit, + require_jit=require_jit, + partitions=partitions, + cardinality=cardinality, + ndim=ndim, + casting=casting, + ) + + return decorate if func is None else decorate(func) diff --git a/src/blosc2/msgpack_utils.py b/src/blosc2/msgpack_utils.py index b95890fcf..2854bb0ab 100644 --- a/src/blosc2/msgpack_utils.py +++ b/src/blosc2/msgpack_utils.py @@ -48,7 +48,7 @@ def _encode_structured_reference(obj): return None -def _decode_structured_reference(data): +def _decode_structured_reference(data, *, deserialize="safe"): payload = unpackb(data) if not isinstance(payload, dict): raise TypeError("Structured Blosc2 msgpack payload must decode to a mapping") @@ -61,8 +61,8 @@ def _decode_structured_reference(data): if kind == "ref": ref_payload = payload.get("ref") return Ref.from_dict(ref_payload) - if kind in {"c2array", "lazyexpr", "lazyudf"}: - return decode_b2object_payload(payload) + if kind in {"c2array", "lazyexpr", "lazyudf", "portable"}: + return decode_b2object_payload(payload, deserialize=deserialize) raise ValueError(f"Unsupported structured Blosc2 msgpack payload kind: {kind!r}") @@ -80,7 +80,7 @@ def _encode_ndarray(value): return ExtType(_BLOSC2_NDARRAY_EXT_CODE, msgpack_packb(payload)) -def _decode_ndarray(data, *, deserialize=DeserializeMode.FULL): +def _decode_ndarray(data, *, deserialize=DeserializeMode.SAFE): from blosc2.hdf5_source import dtype_from_value payload = msgpack_unpackb(data, deserialize=deserialize) @@ -139,34 +139,38 @@ def decode_tuple_list_hook(obj): return obj -def _decode_msgpack_ext(code, data): +def _decode_msgpack_ext(code, data, *, deserialize=DeserializeMode.SAFE): import blosc2 if code == _BLOSC2_EXT_CODE: - return blosc2.from_cframe(data, copy=True, deserialize="full") + return blosc2.from_cframe(data, copy=True, deserialize=deserialize) if code == _BLOSC2_STRUCTURED_EXT_CODE: - return _decode_structured_reference(data) + return _decode_structured_reference(data, deserialize=deserialize) if code == _BLOSC2_COMPLEX_EXT_CODE: real, imag = struct.unpack(">dd", data) return complex(real, imag) if code == _BLOSC2_NDARRAY_EXT_CODE: - return _decode_ndarray(data, deserialize=DeserializeMode.FULL) + return _decode_ndarray(data, deserialize=deserialize) if code == _BLOSC2_SET_EXT_CODE: - return set(msgpack_unpackb(data)) + return set(msgpack_unpackb(data, deserialize=deserialize)) return ExtType(code, data) -def msgpack_unpackb(payload, *, deserialize=DeserializeMode.FULL): +def msgpack_unpackb(payload, *, deserialize=DeserializeMode.SAFE): """Decode a Blosc2 MessagePack value under the selected policy. - This low-level helper retains ``"full"`` as its default for compatibility. - APIs accepting persisted input pass their safe-by-default policy explicitly. + Active reconstruction requires explicit ``deserialize="full"``. Container + readers pass their effective policy through recursive values unchanged. """ mode = normalize_deserialize(deserialize) if mode is DeserializeMode.SAFE: return _safe_msgpack_unpackb(payload) - return unpackb(payload, list_hook=decode_tuple_list_hook, ext_hook=_decode_msgpack_ext) + return unpackb( + payload, + list_hook=decode_tuple_list_hook, + ext_hook=lambda code, data: _decode_msgpack_ext(code, data, deserialize=mode), + ) def _safe_msgpack_unpackb(payload): @@ -205,12 +209,15 @@ def decode_ext(code, data): if code == _BLOSC2_EXT_CODE: kind = "embedded cframe" elif code == _BLOSC2_STRUCTURED_EXT_CODE: + candidate = None try: envelope = unpackb(data) candidate = envelope.get("kind") if isinstance(envelope, dict) else None kind = candidate if isinstance(candidate, str) else "structured reference" except Exception: kind = "structured reference" + if candidate in {"portable", "lazyexpr"}: + return decode_b2object_payload(envelope, deserialize="safe") else: kind = f"MessagePack extension code {code}" raise UnsafeDeserializationError(str(kind)) diff --git a/src/blosc2/native_graph.py b/src/blosc2/native_graph.py new file mode 100644 index 000000000..1ec751d16 --- /dev/null +++ b/src/blosc2/native_graph.py @@ -0,0 +1,1871 @@ +"""Native graph lowering; Python is metadata/storage frontend only. + +Plans own scalar captures, not operand results. This module contains no fallback +to an unrelated expression engine. Table selections, opaque operands and nested +lazy values are deliberately outside the eligible subset. +""" + +from __future__ import annotations + +import ast +import json +import math +import os +import struct +import sys +import threading +from collections import OrderedDict +from functools import lru_cache + +import numpy as np + +from .expression_graph import expression_syntax, parse_expression, validate_operands + +REDUCERS = {"sum", "prod", "min", "max", "any", "all"} +PARALLEL_GRAPH_REDUCERS = {"sum", "min", "max", "any", "all"} +TRUTH_GRAPH_REDUCERS = {"any", "all"} +MINIMUM_COMPRESSED_GRAPH_ITEMS = 16_000_000 +MINIMUM_COMPRESSED_MAP_ITEMS = 2_000_000 +_NATIVE_PLAN_CACHE_SIZE = 128 +_MINIMUM_PARALLEL_ITEMS = 2 * 128 * 1024 +_native_plan_cache = OrderedDict() +_native_plan_cache_lock = threading.Lock() +NATIVE_ELEMENTWISE_CALLS = { + **dict.fromkeys( + ( + "abs", + "copy", + "fabs", + "sqrt", + "cbrt", + "sin", + "cos", + "tan", + "asin", + "acos", + "atan", + "arcsin", + "arccos", + "arctan", + "sinh", + "cosh", + "tanh", + "asinh", + "acosh", + "atanh", + "arcsinh", + "arccosh", + "arctanh", + "exp", + "exp2", + "expm1", + "exp10", + "log", + "log2", + "log10", + "log1p", + "erf", + "erfc", + "lgamma", + "tgamma", + "ceil", + "floor", + "trunc", + "round", + "rint", + "square", + "sign", + "real", + "imag", + "conj", + "sinpi", + "cospi", + "isfinite", + "isinf", + "isnan", + "signbit", + ), + 1, + ), + **dict.fromkeys( + ( + "atan2", + "arctan2", + "copysign", + "fdim", + "hypot", + "nextafter", + "fmod", + "remainder", + "pow", + "power", + "minimum", + "maximum", + "fmin", + "fmax", + "logaddexp", + "ldexp", + ), + 2, + ), + "fma": 3, + "where": 3, +} + + +def _native_first_operand(value): + import blosc2 + + if type(value) in (np.ndarray, blosc2.NDArray) or isinstance(value, np.generic): + if ( + value.dtype.kind not in "biuf" + or value.dtype.itemsize > 8 + or not value.dtype.isnative + or value.dtype == np.dtype("float16") + ): + return False + if type(value) in (np.ndarray, blosc2.NDArray): + return bool(value.size) + elif type(value) not in (bool, int, float): + return False + if type(value) is int and not -(1 << 63) <= value < (1 << 63): + return False + try: + scalar_descriptor(value) + except ValueError: + return False + return True + + +@lru_cache(maxsize=256) +def _native_first_syntax(expression, *, reduction_only=False): # noqa: C901 -- explicit syntax/arity admission + # Deliberately exclude arbitrary calls, nested reductions, indexing and + # Python short-circuit expressions. Numeric inference remains native-owned. + allowed = ( + ast.Expression, + ast.Name, + ast.Load, + ast.Constant, + ast.BinOp, + ast.UnaryOp, + ast.Compare, + ast.Add, + ast.Sub, + ast.Mult, + ast.Div, + ast.FloorDiv, + ast.Mod, + ast.Pow, + ast.LShift, + ast.RShift, + ast.UAdd, + ast.USub, + ast.Invert, + ast.BitAnd, + ast.BitOr, + ast.BitXor, + ast.Eq, + ast.NotEq, + ast.Lt, + ast.LtE, + ast.Gt, + ast.GtE, + ) + try: + tree, nodes = expression_syntax(expression) + except SyntaxError: + return False + if isinstance(tree.body, ast.Call): + call = tree.body + reducers = PARALLEL_GRAPH_REDUCERS if reduction_only else REDUCERS + if isinstance(call.func, ast.Name) and call.func.id in reducers and len(call.args) == 1: + value = call.args[0] + elif isinstance(call.func, ast.Attribute) and call.func.attr in reducers and not call.args: + value = call.func.value + elif ( + isinstance(call.func, ast.Name) + and call.func.id in NATIVE_ELEMENTWISE_CALLS + and not reduction_only + ): + value = None + else: + return False + seen = set() + for keyword in call.keywords: + if keyword.arg not in {"axis", "keepdims", "dtype", "initial"} or keyword.arg in seen: + return False + seen.add(keyword.arg) + try: + ast.literal_eval(keyword.value) + except (ValueError, TypeError): + return False + if value is not None: + tree = ast.Expression(body=value) + nodes = ast.walk(tree) + elif reduction_only: + return False + for node in nodes: + if isinstance(node, ast.Call): + if ( + not isinstance(node.func, ast.Name) + or node.func.id not in NATIVE_ELEMENTWISE_CALLS + or node.keywords + or len(node.args) != NATIVE_ELEMENTWISE_CALLS[node.func.id] + ): + return False + continue + if not isinstance(node, allowed): + return False + if isinstance(node, ast.Compare) and len(node.ops) != 1: + return False + if isinstance(node, ast.Constant) and not _native_first_operand(node.value): + return False + return True + + +def _native_first_array(value): + """Exact array operand for automatic ingestion; rejects object/exotic dtypes cheaply.""" + import blosc2 + + if type(value) not in (np.ndarray, blosc2.NDArray): + return False + dtype = value.dtype + if ( + dtype.kind not in "biuf" + or dtype.itemsize > 8 + or not dtype.isnative + or dtype.metadata is not None + or (dtype.kind == "f" and dtype.itemsize == 2) + ): + return False + return bool(value.size) + + +def _native_plan_cache_key(expr, jit, options, configuration=None): + """Metadata-only plan-cache key; never retains operand or output arrays.""" + import blosc2 + + if type(expr.operands) is not dict or not expr.operands: + return None + signature = [] + for name, value in sorted(expr.operands.items()): + if type(value) not in (np.ndarray, blosc2.NDArray): + return None + compressed = type(value) is blosc2.NDArray + signature.append( + ( + name, + type(value).__name__, + value.dtype.str, + repr(value.dtype.metadata), + tuple(value.shape), + getattr(value, "chunks", None) if compressed else None, + getattr(value, "blocks", None) if compressed else None, + ) + ) + return ( + expr.expression, + tuple(signature), + jit, + _graph_configuration(jit) if configuration is None else configuration, + getattr(expr, "_evaluation", "full"), + bool(options.get("_getitem", False)), + ) + + +def _resident_signature(expression, inputs, jit): + import blosc2 + + if not inputs: + return None + first = None + dtypes = [] + for name, value in inputs.items(): + if type(value) is not np.ndarray: + return None + dtype = value.dtype + if ( + dtype.kind not in "biuf" + or dtype.itemsize > 8 + or not dtype.isnative + or dtype.metadata is not None + or (dtype.kind == "f" and dtype.itemsize == 2) + or not value.flags.c_contiguous + or not value.flags.aligned + ): + return None + if first is None: + first = value + if not value.size: + return None + elif value.shape != first.shape: + return None + dtypes.append((name, dtype.str)) + configuration = (_graph_configuration(jit), tuple(blosc2.jit_config.execution_options().items())) + return (expression, tuple(dtypes), first.shape, jit, configuration) + + +def native_weak_scalars_eligible(plan, expression, inputs): + """Retain NumPy's preparation-time scalar range errors for checked native maps.""" + return plan.partitionable or (parse_expression(expression).infer_dtype(inputs) is not None) + + +def prepare_resident(expression, inputs, *, jit=None, cached=None, plan=None): + """Prepare an admitted resident map; retain metadata and native owners only.""" + import blosc2 + + signature = _resident_signature(expression, inputs, jit) + if signature is None: + return None + parallel = math.prod(signature[2]) >= _MINIMUM_PARALLEL_ITEMS + if parallel and ( + blosc2.IS_WASM + or not getattr(blosc2.blosc2_ext, "native_graph_output_available", lambda: False)() + or not getattr(blosc2.blosc2_ext, "portable_resident_available", lambda: False)() + ): + return None + if cached is not None and cached[0] == signature: + return cached + try: + if plan is None: + plan = compile_plan( + expression, + jit, + signature[-1], + input_dtypes=tuple((name, value.dtype) for name, value in inputs.items()), + ) + # Checked conversions and mixed-type errors retain their whole-domain execution order. + if plan.stages != 1 or (parallel and not plan.partitionable): + return None + schedule = plan.specialize( + {name: (value.dtype, value.shape) for name, value in inputs.items()}, 65536 + ) + info = schedule.info() + if info["shape"] != next(iter(inputs.values())).shape or info["dtype"].kind not in "biuf": + return None + if not native_weak_scalars_eligible(plan, expression, inputs): + return None + except (NotImplementedError, blosc2.PortableArtifactError, TypeError, ValueError): + return None + return signature, plan, schedule + + +def execute_resident(prepared, inputs, *, out=None): + """Bind current arrays and thread count to an admitted native schedule.""" + import blosc2 + + workers = min(blosc2.nthreads, 32) if math.prod(prepared[0][2]) >= _MINIMUM_PARALLEL_ITEMS else 1 + return prepared[2].execute(inputs, out=out, workers=workers) + + +def compute_resident_if_eligible(expr, item, *, jit=None, jit_backend=None, fp_accuracy=None, options=None): + """Bind current arrays to a prepared whole-domain map without general graph/storage dispatch.""" + import blosc2 + + prepared = getattr(expr, "_resident_native", None) + if prepared is None or jit_backend is not None or fp_accuracy is not None: + return None + options = options or {} + output = options.get("out", getattr(expr, "_output", None)) + if ( + type(expr) is not blosc2.LazyExpr + or any(hasattr(expr, name) for name in ("_where_args", "_indices", "_order")) + or getattr(expr, "_ne_args", None) is not None + or options.keys() - {"_getitem", "out"} + or (not options.get("_getitem", False) and type(output) is not np.ndarray) + or ("out" in options and output is None) + ): + return None + selection = item if isinstance(item, tuple) else (item,) + if len(selection) > len(prepared[0][2]) or any( + not isinstance(part, slice) or part != slice(None) for part in selection + ): + return None + if prepared[0] != _resident_signature(expr.expression, expr.operands, jit): + return None + _, plan, schedule = prepared + if output is not None and ( + type(output) is not np.ndarray + or not getattr(blosc2.blosc2_ext, "native_graph_output_available", lambda: False)() + or not output.flags.c_contiguous + or not _native_cached_output_ok(expr, schedule, output) + ): + return None + # Once execution starts, errors propagate; no other route may replay a failed kernel. + result, report = execute_resident(prepared, expr.operands, out=output) + expr._native_execution_report = { + **report, + "route": "parallel-resident" if report["tasks"] > 1 else "native-resident", + "threads": report["tasks"], + "semantic_revision": "menudet-numpy-1.0", + "backend": "portable-jit" if report["jit_stages"] else "portable-interpreter", + "frontend": getattr(plan, "_frontend", "native-expression"), + "plan_cache": compile_plan.cache_info()._asdict(), + "input_materialization_bytes": 0, + "output_copy_bytes": 0, + } + return result + + +def _native_cached_output_ok(expr, schedule, output): + import blosc2 + + if output is None: + return True + if type(output) is not np.ndarray: + return False + info = schedule.info() + if output.shape != info["shape"] or output.dtype != info["dtype"]: + return False + if not output.flags.writeable or not output.flags.aligned or not output.dtype.isnative: + return False + if ( + not output.flags.c_contiguous + and not getattr(blosc2.blosc2_ext, "native_graph_output_available", lambda: False)() + ): + return False + return not any( + type(value) is np.ndarray and np.shares_memory(output, value) for value in expr.operands.values() + ) + + +def prepare_native_first(expr, item, *, jit=True, jit_backend=None, fp_accuracy=None, options=None): # noqa: C901 -- conservative metadata-only admission gates + """Prepare the conservative automatic subset, without reading array values. + + Return None for unsupported requests. Execution errors are never caught here: + once a prepared plan is selected, callers must not replay it on another route. + Compressed inputs require a single region and graph reader support. + Proxy inputs remain outside this automatic subset. + """ + import blosc2 + + if jit_backend is not None or fp_accuracy is not None: + return None + if type(expr) is not blosc2.LazyExpr or any( + hasattr(expr, name) for name in ("_where_args", "_indices", "_order") + ): + return None + if getattr(expr, "_ne_args", None) is not None: + return None + options = options or {} + output = options.get("out", getattr(expr, "_output", None)) + # Only a concrete, validated NumPy output extends the old admission gate. + if "out" in options and output is None: + return None + if output is not None and type(output) is not np.ndarray: + return None + explicit = options.get("_reduce_args") + reduction_options = None + if explicit is not None: + if not {"op", "op_str", "axis", "keepdims"} <= explicit.keys(): + return None + if explicit["op_str"] not in REDUCERS: + return None + reduction_options = { + "reduction": explicit["op_str"], + "axis": explicit["axis"], + "dtype": explicit.get("dtype"), + "keepdims": explicit["keepdims"], + } + if options.keys() - {"_getitem", "_reduce_args", "initial", "out"}: + return None + cache_key = None + if ( + ((isinstance(item, tuple) and not item) or (isinstance(item, slice) and item == slice(None))) + and explicit is None + and "initial" not in options + ): + cache_key = _native_plan_cache_key(expr, jit, options) + if cache_key is not None: + with _native_plan_cache_lock: + cached = _native_plan_cache.get(cache_key) + if cached is not None: + _native_plan_cache.move_to_end(cache_key) + if cached is None: + prepared = getattr(expr, "_prepared_native", None) + if prepared is not None and prepared[0] == cache_key: + cached = prepared[1] + # Locally prepared plans also participate in shared reuse and eviction. + with _native_plan_cache_lock: + _native_plan_cache[cache_key] = cached + _native_plan_cache.move_to_end(cache_key) + while len(_native_plan_cache) > _NATIVE_PLAN_CACHE_SIZE: + _native_plan_cache.popitem(last=False) + if cached is not None: + plan, input_names, reduction = cached + # The cache key validates input metadata; only a destination needs another preflight. + if output is not None: + try: + schedule = plan.specialize( + { + name: (expr.operands[name].dtype, expr.operands[name].shape) + for name in input_names + } + ) + except (ValueError, TypeError, blosc2.PortableArtifactError): + return None + if not _native_cached_output_ok(expr, schedule, output): + return None + return plan, {name: expr.operands[name] for name in input_names}, reduction + # Only whole-domain reads: even a full slice of a staged graph is currently + # treated as a partial read by the strict adapter. + selection = item if isinstance(item, tuple) else (item,) + if any(not isinstance(s, slice) or s != slice(None) for s in selection): + return None + if not all(_native_first_operand(value) for value in expr.operands.values()): + return None + compressed = any(type(value) is blosc2.NDArray for value in expr.operands.values()) + if output is not None and explicit is not None: + return None + if compressed and not getattr(blosc2.blosc2_ext, "native_graph_sources_available", lambda: False)(): + return None + if compressed: + size = max(value.size for value in expr.operands.values() if type(value) is blosc2.NDArray) + if size < min(MINIMUM_COMPRESSED_GRAPH_ITEMS, MINIMUM_COMPRESSED_MAP_ITEMS): + return None + reduction_request = explicit is not None or _native_first_syntax( + expr.expression, reduction_only=True + ) + minimum = ( + MINIMUM_COMPRESSED_GRAPH_ITEMS if reduction_request else _compressed_map_minimum(expr.operands) + ) + if size < minimum: + return None + if not any(type(value) in (np.ndarray, blosc2.NDArray) for value in expr.operands.values()): + return None + if compressed and explicit is not None and explicit["op_str"] not in PARALLEL_GRAPH_REDUCERS: + return None + if not _native_first_syntax(expr.expression): + return None + if any( + isinstance(node, ast.Name) + and node.id not in expr.operands + and node.id not in REDUCERS + and node.id not in NATIVE_ELEMENTWISE_CALLS + for node in ast.walk(ast.parse(expr.expression, mode="eval")) + ): + return None + try: + prepared = lower_native_graph( + expr, + jit=jit, + reduction_options=reduction_options, + root_options={"initial": options["initial"]} if "initial" in options else None, + allow_output=True, + ) + if prepared[2] and selection: + return None + if output is not None and prepared[2] and compressed: + return None + if compressed and prepared[0].info()["stages"] != 1: + return None + if compressed and not prepared[2] and not options.get("_getitem", False): + return None # Compressed-result compute() keeps its prefilter route. + # Native preparation and specialization own dtype/broadcast validation. + # Neither phase evaluates operands or creates an output destination. + schedule = prepared[0].specialize( + {name: (value.dtype, value.shape) for name, value in prepared[1].items()} + ) + if output is not None and ( + output.shape != schedule.info()["shape"] + or output.dtype != schedule.info()["dtype"] + or ( + not output.flags.c_contiguous + and not getattr(blosc2.blosc2_ext, "native_graph_output_available", lambda: False)() + ) + or not output.flags.aligned + or not output.flags.writeable + or any( + type(value) is np.ndarray and np.shares_memory(output, value) + for value in prepared[1].values() + ) + ): + return None + if len(selection) > len(schedule.info()["map_shape"]): + return None + if ( + compressed + and _compressed_execution_layout( + prepared[0], prepared[1], schedule.info()["map_shape"], reduction=prepared[2] + ) + is None + ): + return None + except NotImplementedError: + return None # Older installed miniexpr without graph support. + except blosc2.PortableArtifactError as error: + if error.status not in {"invalid_signature", "unsupported"}: + raise + return None + if cache_key is not None and not prepared[2] and all(name in expr.operands for name in prepared[1]): + with _native_plan_cache_lock: + _native_plan_cache[cache_key] = (prepared[0], tuple(prepared[1]), False) + _native_plan_cache.move_to_end(cache_key) + while len(_native_plan_cache) > _NATIVE_PLAN_CACHE_SIZE: + _native_plan_cache.popitem(last=False) + return prepared + + +def compute_native_prefilter_if_eligible( # noqa: C901 -- metadata-only layout/output admission + expr, item, *, jit=True, jit_backend=None, fp_accuracy=None, options=None +): + """Use the shared portable prefilter for matching Blosc2 result storage.""" + from types import SimpleNamespace + + import blosc2 + + from .storage_readers import compute_storage_if_eligible + + if jit_backend is not None or fp_accuracy is not None: + return None + if type(expr) is not blosc2.LazyExpr or any( + hasattr(expr, name) for name in ("_where_args", "_indices", "_order") + ): + return None + if getattr(expr, "_ne_args", None) is not None: + return None + options = dict(options or {}) + if options.pop("_getitem", False): + return None + options.pop("_use_index", None) + if options.keys() - { + "out", + "chunks", + "blocks", + "cparams", + "dparams", + "meta", + "urlpath", + "contiguous", + "mode", + "mmap_mode", + "initial_mapping_size", + "locking", + "storage", + }: + return None + output = options.get("out", getattr(expr, "_output", None)) + if output is not None: + if type(output) is not blosc2.NDArray: + return None + options["out"] = output + selection = item if isinstance(item, tuple) else (item,) + if any(not isinstance(s, slice) or s != slice(None) for s in selection): + return None + values = tuple(expr.operands.values()) + resident = bool(values) and all( + type(value) is np.ndarray + and value.ndim == 1 + and value.shape == values[0].shape + and value.flags.c_contiguous + and value.flags.aligned + for value in values + ) + if ( + output is not None + and not resident + and not all( + output.ndim == 1 + and type(value) is blosc2.NDArray + and value.dtype.kind in "biuf" + and value.shape == output.shape + and value.chunks == output.chunks + and value.blocks == output.blocks + for value in expr.operands.values() + ) + ): + stored = _compute_native_stored_output(expr, output, options, jit=jit) + if stored is not None: + return stored + # Mixed storage, broadcasting and scalar operands retain their existing + # stored-output fallback. Admission must remain metadata-only. + if not values or any( + (type(value) is not blosc2.NDArray and not resident) + or value.dtype.kind not in "biuf" + or not _native_first_operand(value) + for value in values + ): + return None + first = values[0] + if ( + first.ndim != 1 + or not first.size + or any( + value.shape != first.shape + or (not resident and (value.chunks != first.chunks or value.blocks != first.blocks)) + for value in values + ) + ): + return None + if not _native_first_syntax(expr.expression): + return None + if any( + isinstance(node, ast.Name) + and node.id not in expr.operands + and node.id not in NATIVE_ELEMENTWISE_CALLS + for node in ast.walk(ast.parse(expr.expression, mode="eval")) + ): + return None + try: + plan, inputs, reduction = lower_native_graph(expr, jit=jit, allow_output=True) + if reduction or plan.info()["stages"] != 1: + return None + kernel = resident_map_kernel(plan) + except NotImplementedError: + return None + except blosc2.PortableArtifactError as error: + if error.status not in {"invalid_signature", "unsupported"}: + raise + return None + if kernel is None or kernel.output_dtype != expr.dtype: + return None + lazy = SimpleNamespace( + kernel=kernel, inputs=inputs, _domain=first.shape, shape=first.shape, dtype=expr.dtype + ) + result = compute_storage_if_eligible(lazy, options) + if result is None: + if output is not None: + return _compute_native_stored_output(expr, output, options, jit=jit) + return None + output, report = result + expr._native_execution_report = { + **report, + "semantic_revision": "menudet-numpy-1.0", + "backend": "portable-jit" if plan.has_jit else "portable-interpreter", + "frontend": getattr(plan, "_frontend", "declarative-json"), + "plan_cache": compile_plan.cache_info()._asdict(), + "input_materialization_bytes": 0, + "output_copy_bytes": 0, + } + return output + + +def _compute_native_stored_output(expr, output, options, *, jit=True): + """Bounded native elementwise tiles for an explicit Blosc2 destination. + + This also covers mixed NumPy/compressed operands and storage layouts that + compression-prefilter admission excludes. Preparation completes + before reads/writes; numerical or storage failures are never replayed. + """ + import blosc2 + + if options.keys() - {"out"} or not output.ndim or not output.size: + return None + if not _native_first_syntax(expr.expression) or not all( + _native_first_operand(value) for value in expr.operands.values() + ): + return None + if any( + type(value) is blosc2.NDArray + and ( + value is output + or value.schunk is output.schunk + or (value.urlpath is not None and value.urlpath == output.urlpath) + ) + for value in expr.operands.values() + ): + return None + try: + plan, inputs, reduction = lower_native_graph(expr, jit=jit, allow_output=True) + # This schedule runs serial, bounded native tiles; interpreter artifacts + # have the same binding/lifetime contract and do not require JIT. + if reduction or plan.info()["stages"] != 1: + return None + schedule = plan.specialize({name: (value.dtype, value.shape) for name, value in inputs.items()}) + if schedule.info()["shape"] != output.shape or schedule.info()["dtype"] != output.dtype: + return None + except NotImplementedError: + return None + except blosc2.PortableArtifactError as error: + if error.status not in {"invalid_signature", "unsupported"}: + raise + return None + report = { + "route": "bounded-stored-map", + "backend": "portable-jit" if plan.has_jit else "portable-interpreter", + "fp_flags": 0, + "fp_supported": True, + "maximum_input_items": 0, + "output_copy_bytes": output.nbytes, + } + tile_shape = list(output.chunks) + while math.prod(tile_shape) > 262144: + axis = max(range(output.ndim), key=tile_shape.__getitem__) + tile_shape[axis] = max(1, tile_shape[axis] // 2) + grid = tuple((size + tile - 1) // tile for size, tile in zip(output.shape, tile_shape, strict=True)) + for index in np.ndindex(grid): + selection = tuple( + slice(i * tile, min((i + 1) * tile, size)) + for i, tile, size in zip(index, tile_shape, output.shape, strict=True) + ) + arrays = {} + for name, value in inputs.items(): + source_item = ( + tuple( + slice(None) if size == 1 else part + for size, part in zip(value.shape, selection[output.ndim - value.ndim :], strict=True) + ) + if value.ndim + else () + ) + arrays[name] = value[source_item] + # A length-one compressed operand still has to be read, not passed to + # the resident schedule as an opaque storage object. + arrays = { + name: value[:] if type(value) is blosc2.NDArray else value for name, value in arrays.items() + } + tile = plan.specialize({name: (value.dtype, value.shape) for name, value in arrays.items()}) + values, status = tile.execute(arrays) + output[selection] = values + report["fp_flags"] |= status["fp_flags"] + report["fp_supported"] &= status["fp_supported"] + report["maximum_input_items"] = max(report["maximum_input_items"], values.size) + expr._native_execution_report = report + return output + + +def _parallel_resident_reduction(plan, inputs, shape, tile_items): + """Automatic whole-domain reductions; strict native execution keeps serial order.""" + from concurrent.futures import wait + + import blosc2 + + from .resident_execution import MAXIMUM_WORKERS, MINIMUM_WORKER_ITEMS, resident_pool + + count = math.prod(shape) + workers = min(blosc2.nthreads, MAXIMUM_WORKERS, count // MINIMUM_WORKER_ITEMS) + if workers < 2 or blosc2.IS_WASM or plan.info()["stages"] != 1 or not inputs: + return None + info = plan.reduction_info() + if info is None or info["op"] not in PARALLEL_GRAPH_REDUCERS or info["initial"] or info["where"]: + return None + axes = info["axes"] + if axes is not None and {a % len(shape) for a in axes} != set(range(len(shape))): + return None + input_kinds = "biuf" if info["op"] in TRUTH_GRAPH_REDUCERS else "f" + output_kind = "b" if info["op"] in TRUTH_GRAPH_REDUCERS else "f" + if any( + type(value) is not np.ndarray + or value.shape != shape + or value.dtype.kind not in input_kinds + or not value.flags.c_contiguous + or not value.flags.aligned + for value in inputs.values() + ): + return None + # Keep the original rank/axes; split the first dimension into full C-order slabs. + workers = min(workers, shape[0]) + if workers < 2: + return None + schedules = [] + # Map calls validate bindings and isolate FP state per tile. Small tiles + # amplify that overhead and environment-lock contention between workers; + # 4096 lanes keeps float64 scratch at 32 KiB per worker. + worker_tile_items = max(tile_items, 4096) + for worker in range(workers): + start, stop = shape[0] * worker // workers, shape[0] * (worker + 1) // workers + arrays = {name: value[start:stop] for name, value in inputs.items()} + schedule = plan.specialize( + {name: (value.dtype, value.shape) for name, value in arrays.items()}, worker_tile_items + ) + if schedule.info()["dtype"].kind != output_kind: + return None + schedules.append((schedule, arrays)) + futures = [] + try: + for schedule, arrays in schedules: + futures.append(resident_pool().submit(schedule.execute, arrays)) + finally: + # Never replay failures; join all workers before releasing their inputs. + wait(futures) + results, reports = zip(*(future.result() for future in futures), strict=True) + result, report = _combine_graph_reductions(info["op"], results, reports) + report.update(route="parallel-resident-reduction", threads=workers) + return result, report + + +def _combine_graph_reductions(op, results, reports): + # Combine in logical region order through the same native reducer. Extrema + # retain first-NaN payload selection and their deterministic signed-zero rule; + # NumPy's minimum/maximum reductions have a different zero-selection policy. + partials = np.stack(results) + document = { + "format": "menudet-graph-1", + "semantics": "menudet-numpy-1.0", + "requires": ["numeric"], + "nodes": [ + {"id": 0, "op": "input", "name": "partials", "dtype": partials.dtype.name}, + { + "id": 1, + "op": op, + "args": [0], + "axes": [0], + "keepdims": False, + "dtype": "auto" if op in TRUTH_GRAPH_REDUCERS else partials.dtype.name, + "initial": None, + "where": None, + }, + ], + "root": 1, + "output": {"dtype": "auto", "casting": "unsafe"}, + } + combine = compile_plan(json.dumps(document, sort_keys=True, separators=(",", ":"))) + result, combined_report = combine.evaluate({"partials": partials}, return_report=True) + report = dict(reports[0]) + for key in ( + "evaluated_tiles", + "zero_copy_tiles", + "gathered_bytes", + "temporary_bytes", + "normalization_bytes", + ): + report[key] = sum(part[key] for part in reports) + report["fp_flags"] = combined_report["fp_flags"] + for part in reports: + report["fp_flags"] |= part["fp_flags"] + report["fp_supported"] = combined_report["fp_supported"] and all( + part["fp_supported"] for part in reports + ) + return result, report + + +def _compressed_map_minimum(inputs): + """Lower the crossover for measured high-thread float64/prefilter maps.""" + import blosc2 + + arrays = [value for value in inputs.values() if type(value) in (np.ndarray, blosc2.NDArray)] + if blosc2.nthreads >= 8 and arrays and all(value.dtype == np.dtype("float64") for value in arrays): + return MINIMUM_COMPRESSED_MAP_ITEMS + if ( + blosc2.nthreads >= 8 + and arrays + and all(value.dtype in (np.dtype("int32"), np.dtype("int64")) for value in arrays) + and blosc2.blosc2_ext.portable_prefilter_inputs_eligible(inputs, allow_numpy=True) + ): + return MINIMUM_COMPRESSED_MAP_ITEMS + return MINIMUM_COMPRESSED_GRAPH_ITEMS + + +def _compressed_map_blocks(first, size): + """Count physical blocks containing logical values, excluding tail padding.""" + chunk, block = first.chunks[0], first.blocks[0] + full_chunks = (size - 1) // chunk + blocks_per_chunk = (chunk + block - 1) // block + tail_items = size - full_chunks * chunk + return full_chunks * blocks_per_chunk + (tail_items + block - 1) // block + + +def _compressed_execution_layout(plan, inputs, shape, *, reduction=True): + """Conservative metadata-only automatic gate; avoid small/serial IO regressions.""" + import blosc2 + + from .resident_execution import MAXIMUM_WORKERS, MINIMUM_WORKER_ITEMS + + compressed = [value for value in inputs.values() if type(value) is blosc2.NDArray] + if len(shape) != 1 or not compressed or blosc2.IS_WASM or plan.info()["stages"] != 1: + return None + minimum = MINIMUM_COMPRESSED_GRAPH_ITEMS if reduction else _compressed_map_minimum(inputs) + if shape[0] < minimum: + return None + first = compressed[0] + units = first.schunk.nchunks if reduction else _compressed_map_blocks(first, shape[0]) + workers = min(blosc2.nthreads, MAXIMUM_WORKERS, shape[0] // MINIMUM_WORKER_ITEMS, units) + if workers < 2: + return None + if reduction: + info = plan.reduction_info() + if ( + info is None + or info["op"] not in PARALLEL_GRAPH_REDUCERS + or info["axes"] not in (None, (0,), (-1,)) + or info["initial"] + or info["where"] + ): + return None + op = info["op"] + input_kinds = "biuf" if op in TRUTH_GRAPH_REDUCERS else "f" + else: + op = None + input_kinds = "biuf" + if any( + type(value) not in (np.ndarray, blosc2.NDArray) + or value.shape != shape + or value.dtype.kind not in input_kinds + or not value.dtype.isnative + or (type(value) is np.ndarray and (not value.flags.c_contiguous or not value.flags.aligned)) + for value in inputs.values() + ): + return None + if any(value.chunks != first.chunks or value.blocks != first.blocks for value in compressed): + return None + if first.blocks[0] > 65536: + return None + return first, workers, op + + +def _parallel_compressed_reduction(plan, inputs, shape, tile_items): + """Stream independent 1-D chunk regions with bounded, invocation-local readers.""" + from concurrent.futures import wait + + import blosc2 + + from .resident_execution import resident_pool + from .storage_readers import ReaderState, StorageReader + + layout = _compressed_execution_layout(plan, inputs, shape) + if layout is None: + return None + first, workers, op = layout + output_kind = "b" if op in TRUTH_GRAPH_REDUCERS else "f" + + class SpanReader(StorageReader): + def __init__(self, value, start, stop): + super().__init__(value, shape) + self.start = start + self.shape = (stop - start,) + + def read(self, indices): + return super().read(indices + self.start) + + # Match tiles to compression blocks so adjacent requests do not decompress + # the same boundary block twice. Scratch scales with tiles, never array size. + block = first.blocks[0] + target = max(tile_items, 65536) + worker_tile = max(1, target // block) * block if block <= target else target + schedules = [] + for worker in range(workers): + start = first.schunk.nchunks * worker // workers * first.chunks[0] + stop = min(shape[0], first.schunk.nchunks * (worker + 1) // workers * first.chunks[0]) + arrays = { + name: value if type(value) is blosc2.NDArray else value[start:stop] + for name, value in inputs.items() + } + readers = { + name: ReaderState(SpanReader(value, start, stop)) + for name, value in inputs.items() + if type(value) is blosc2.NDArray + } + metadata = {name: (value.dtype, (stop - start,)) for name, value in inputs.items()} + schedule = plan.specialize(metadata, worker_tile) + if schedule.info()["dtype"].kind != output_kind: + return None + schedules.append((schedule, arrays, readers)) + futures = [] + try: + for schedule, arrays, readers in schedules: + futures.append( + resident_pool().submit(schedule.execute_sources, arrays, readers, native_spans=True) + ) + finally: + wait(futures) + results, reports = zip(*(future.result() for future in futures), strict=True) + result, report = _combine_graph_reductions(op, results, reports) + report.update( + route="parallel-graph-bounded-readers", + threads=workers, + tile_items=worker_tile, + maximum_reader_items=max(part["maximum_reader_items"] for part in reports), + reader_bytes=sum(part["reader_bytes"] for part in reports), + native_decoder_contexts=sum(part["native_decoder_contexts"] for part in reports), + input_materialization_bytes=0, + ) + return result, report + + +@lru_cache(maxsize=128) +def _compressed_map_schedules(plan, shape, workers, chunk, block, units, worker_tile): + """Reusable immutable region schedules, with no input/output ownership.""" + blocks_per_chunk = (chunk + block - 1) // block + + def region_offset(unit): + nchunk, within_chunk = divmod(unit, blocks_per_chunk) + return min(shape[0], nchunk * chunk + within_chunk * block) + + schedules = [] + dtypes = plan.input_dtypes + for worker in range(workers): + start = region_offset(units * worker // workers) + stop = region_offset(units * (worker + 1) // workers) + schedule = plan.specialize( + {name: (dtype, (stop - start,)) for name, dtype in dtypes.items()}, worker_tile + ) + if schedule.info()["shape"] != (stop - start,): + return None + schedules.append((start, stop, schedule)) + return tuple(schedules) + + +def _prefilter_compressed_map(plan, inputs, workers, out): + import blosc2 + + from .storage_readers import evaluate_prefilter_numpy, storage_reader_eligible + + kernel = resident_map_kernel(plan) + if ( + kernel is not None + and storage_reader_eligible(kernel) + and blosc2.blosc2_ext.portable_prefilter_available() + and blosc2.blosc2_ext.portable_prefilter_inputs_eligible(inputs, allow_numpy=True) + ): + return evaluate_prefilter_numpy(kernel, inputs, out=out, workers=workers) + return None + + +def _parallel_compressed_map(plan, inputs, shape, tile_items, out=None): + """Prefer shared native prefilters; retain bounded readers for other layouts.""" + from concurrent.futures import wait + + import blosc2 + + from .resident_execution import resident_pool + from .storage_readers import ReaderState, StorageReader + + layout = _compressed_execution_layout(plan, inputs, shape, reduction=False) + if layout is None: + return None + first, workers, _ = layout + if tile_items == 1024: + result = _prefilter_compressed_map(plan, inputs, workers, out) + if result is not None: + return result + block = first.blocks[0] + # Match ordinary tiles to one block; group tiny blocks so graph/kernel + # dispatch is still amortized. The reader decodes each block directly into + # iterator scratch, even when a tile contains multiple physical blocks. + worker_tile = ( + max(1, (4096 + block - 1) // block) * block + if tile_items == 1024 + else max(1, max(tile_items, 65536) // block) * block + ) + + class SpanReader(StorageReader): + def __init__(self, value, start, stop): + super().__init__(value, shape) + self.start = start + self.shape = (stop - start,) + + def read(self, indices): + return super().read(indices + self.start) + + units = _compressed_map_blocks(first, shape[0]) + schedules = _compressed_map_schedules(plan, shape, workers, first.chunks[0], block, units, worker_tile) + if schedules is None: + return None + dtype = schedules[0][2].info()["dtype"] + if out is None: + output = np.empty(shape, dtype=dtype) + else: + if type(out) is not np.ndarray or out.shape != shape or out.dtype != dtype: + raise ValueError("Native map output shape/dtype disagree with the expression") + if not out.flags.c_contiguous or not out.flags.aligned or not out.flags.writeable: + raise ValueError("Native map output must be writable, aligned and C-contiguous") + if any(type(value) is np.ndarray and np.shares_memory(out, value) for value in inputs.values()): + raise ValueError("Native map output must not overlap an input") + output = out + futures = [] + try: + for start, stop, schedule in schedules: + arrays = { + name: value if type(value) is blosc2.NDArray else value[start:stop] + for name, value in inputs.items() + } + readers = { + name: ReaderState(SpanReader(value, start, stop)) + for name, value in inputs.items() + if type(value) is blosc2.NDArray + } + futures.append( + resident_pool().submit( + schedule.execute_sources, arrays, readers, native_spans=True, out=output[start:stop] + ) + ) + finally: + wait(futures) # Keep output/readers alive until every submitted worker joins. + reports = [future.result()[1] for future in futures] + report = dict(reports[0]) + for key in ( + "temporary_bytes", + "gathered_bytes", + "normalization_bytes", + "zero_copy_tiles", + "evaluated_tiles", + "reader_bytes", + "native_decoder_contexts", + ): + report[key] = sum(part[key] for part in reports) + report["fp_flags"] = 0 + for part in reports: + report["fp_flags"] |= part["fp_flags"] + report.update( + route="parallel-graph-bounded-map", + threads=workers, + tile_items=worker_tile, + fp_supported=all(part["fp_supported"] for part in reports), + maximum_reader_items=max(part["maximum_reader_items"] for part in reports), + input_materialization_bytes=0, + output_copy_bytes=0, + output_zero_fill_bytes=0, + ) + return output, report + + +@lru_cache(maxsize=128) +def compile_plan(graph, jit=False, configuration=(), *, input_dtypes=None): + """Reusable native plans; cache identity includes explicit captures and policy.""" + from .graph_plan import NativeGraph + + if input_dtypes is None: + plan = NativeGraph(graph, jit=jit) + plan._frontend = "declarative-json" + else: + plan = NativeGraph.from_expression(graph, dict(input_dtypes), jit=jit) + plan._frontend = "native-expression" + return plan + + +@lru_cache(maxsize=128) +def _native_text_expression(expression): + """Prove a shared grammar subset before choosing native text ingestion. + + This checks syntax only; native preparation owns graph construction and + numerical semantics. Method syntax, captures and dtype normalization retain + the declarative adapter until their frontend parity is qualified. + """ + if not _native_first_syntax(expression): + return None + tree, nodes = expression_syntax(expression) + for node in nodes: + if isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == "copy": + return None # The declarative adapter elides this pure value-copy node. + if isinstance(node, ast.Attribute) or (isinstance(node, ast.keyword) and node.arg == "dtype"): + return None + if isinstance(node, ast.Name) and ( + not node.id.isascii() or len(node.id) >= 80 or node.id in {"true", "false", "null"} + ): + return None + # Normalize Python numeric spelling (hex, underscores) without constructing + # graph nodes. The accepted operators share the native parser's precedence. + reduction = ( + isinstance(tree.body, ast.Call) + and isinstance(tree.body.func, ast.Name) + and tree.body.func.id in REDUCERS + ) + return ast.unparse(tree), reduction + + +def _graph_configuration(jit): + policy = tuple((key, os.environ.get(key)) for key in ("ME_SIMD_MATH_BACKEND", "ME_DSL_FP_MODE")) + if jit is False: + return policy + return policy + tuple( + (key, os.environ.get(key)) + for key in ( + "ME_DSL_JIT_COMPILER", + "CC", + "CFLAGS", + "ME_DSL_JIT_TCC_OPTIONS", + "ME_DSL_JIT_CACHE_DIR", + "ME_DSL_JIT", + "ME_DSL_JIT_LIBTCC_PATH", + ) + ) + + +def evaluate_graph_sources(plan, inputs, *, tile_items=65536, raise_mask=0, out=None): + """Single-region native graph reader bindings; metadata validation precedes IO.""" + import blosc2 + + from .storage_readers import ReaderState, StorageReader + + if not getattr(blosc2.blosc2_ext, "native_graph_sources_available", lambda: False)(): + raise NotImplementedError("Native runtime does not support graph storage readers") + if plan.info()["stages"] != 1: + raise ValueError("Storage readers require a single-region graph") + if any(type(value) not in (np.ndarray, blosc2.NDArray) for value in inputs.values()): + raise TypeError("Graph storage readers require NumPy or Blosc2 arrays") + schedule = plan.specialize( + {name: (value.dtype, value.shape) for name, value in inputs.items()}, tile_items + ) + domain = schedule.info()["map_shape"] + readers = { + name: ReaderState(StorageReader(value, domain)) + for name, value in inputs.items() + if type(value) is blosc2.NDArray + } + result, report = schedule.execute_sources(inputs, readers, raise_mask, out=out) + report.update(route="graph-bounded-readers", tile_items=tile_items) + return result, report + + +@lru_cache(maxsize=128) +def resident_map_kernel(plan): + from . import blosc2_ext + from .portable_kernel import PortableArtifactError, PortableKernel + + handle = getattr(plan._handle, "resident_artifact", lambda: None)() + if handle is not None: + # The borrowed handle retains the plan and its validated weak-capture semantics. + kernel = PortableKernel.__new__(PortableKernel) + kernel._handle = kernel._expression_handle = handle + kernel._artifact = kernel._expression_artifact = plan.map_json().encode("utf-8") + kernel._info = handle.info() + if getattr(blosc2_ext, "portable_descriptor_available", lambda: False)(): + kernel._info.update(handle.descriptor_info()) + kernel.native_partitionable = bool(plan.info().get("partitionable", False)) + return kernel + artifact = plan.map_json() + captures = {} + specialize_captures = True + for constant in json.loads(artifact).get("constants", []): + if constant["category"] != "weak": + return None + if constant["encoding"] == "decimal" and constant["dtype"] == "int64": + value = int(constant["value"]) + elif constant["encoding"] == "boolean" and constant["dtype"] == "bool": + value = constant["value"] + elif constant["encoding"] == "ieee754-hex" and constant["dtype"] == "float64": + value = struct.unpack(">d", bytes.fromhex(constant["value"]))[0] + specialize_captures = False + else: + return None + captures[constant["name"]] = value + + class CaptureProof(ast.NodeTransformer): + def visit_Name(self, node): + return ast.copy_location(ast.Constant(captures[node.id]), node) if node.id in captures else node + + def visit_FunctionDef(self, node): + node = self.generic_visit(node) + node.args.args = [arg for arg in node.args.args if arg.arg not in captures] + return node + + manifest = json.loads(artifact) + if specialize_captures: + # Integer and boolean weak captures can be represented exactly as source + # literals, giving graph maps the same arithmetic shape as direct kernels. + tree = ast.fix_missing_locations(CaptureProof().visit(ast.parse(manifest["source"]))) + manifest["source"] = ast.unparse(tree) + "\n" + manifest["constants"] = [] + try: + kernel = PortableKernel.from_json( + json.dumps(manifest, sort_keys=True, ensure_ascii=False, allow_nan=False, separators=(",", ":")), + jit=plan.has_jit, + ) + except PortableArtifactError as error: + if not specialize_captures or error.status not in {"invalid_source", "invalid_signature"}: + raise + # Literal specialization is an optimization only. Keep the original, + # already-validated artifact for source forms that cannot be re-imported. + specialize_captures = False + kernel = PortableKernel.from_json(artifact, jit=plan.has_jit) + if not specialize_captures: + # Keep IEEE payload bits in the executable artifact; the substituted + # source is used only by metadata-only storage eligibility checks. + kernel._info["source"] = ast.unparse(CaptureProof().visit(ast.parse(kernel.source))) + kernel.native_partitionable = bool(plan.info().get("partitionable", False)) + return kernel + + +def _parallel_resident_graph(plan, inputs, shape, selection, reduction, out=None): + from types import SimpleNamespace + + import blosc2 + + from .resident_execution import MINIMUM_WORKER_ITEMS, evaluate_resident, evaluate_resident_if_eligible + + if not reduction and math.prod(shape) < 2 * MINIMUM_WORKER_ITEMS: + return None + full_selection = not selection or all( + isinstance(part, slice) and part.indices(size) == (0, size, 1) + for part, size in zip(selection, shape, strict=True) + ) + count = math.prod(shape) + workers = min(blosc2.nthreads, 32, count // MINIMUM_WORKER_ITEMS) + if ( + not reduction + and full_selection + and not blosc2.IS_WASM + and workers >= 2 + and plan.has_jit + and plan.info()["stages"] == 1 + and plan.info().get("partitionable", False) + and all( + type(value) is np.ndarray + and value.shape == shape + and value.flags.c_contiguous + and value.flags.aligned + for value in inputs.values() + ) + and getattr(blosc2.blosc2_ext, "portable_resident_available", lambda: False)() + and ( + out is None + or ( + type(out) is np.ndarray + and out.flags.c_contiguous + and out.flags.aligned + and out.flags.writeable + ) + ) + ): + kernel = resident_map_kernel(plan) + if kernel is not None: + values, report = evaluate_resident(kernel, inputs, shape, workers, out=out) + return values, { + **report, + "route": "parallel-resident", + "stages": 1, + "jit_stages": 1, + "interpreter_stages": 0, + "intermediate_bytes": 0, + "normalization_bytes": 0, + } + + if ( + not reduction + and not selection + and all(type(value) is np.ndarray for value in inputs.values()) + and getattr(blosc2.blosc2_ext, "native_graph_output_available", lambda: False)() + ): + schedule = plan.specialize({name: (value.dtype, value.shape) for name, value in inputs.items()}) + workers = ( + min(blosc2.nthreads, 32) + if ( + not blosc2.IS_WASM + and getattr(blosc2.blosc2_ext, "portable_resident_available", lambda: False)() + ) + else 1 + ) + values, report = schedule.execute(inputs, out=out, workers=workers) + return values, { + **report, + "route": "parallel-resident" if report["tasks"] > 1 else "native-resident", + "threads": report["tasks"], + "normalization_bytes": report.get("normalization_bytes", 0), + "output_copy_bytes": 0, + } + if reduction or not plan.has_jit or plan.info()["stages"] != 1: + return None + if blosc2.nthreads < 2 or math.prod(shape) < 2 * MINIMUM_WORKER_ITEMS: + return None + if any(type(value) is not np.ndarray for value in inputs.values()): + return None + if not full_selection: + return None + kernel = resident_map_kernel(plan) + if kernel is None: + return None + lazy = SimpleNamespace(kernel=kernel, inputs=inputs, _domain=shape) + result = evaluate_resident_if_eligible(lazy, tuple(slice(None) for _ in shape), out=out) + if result is None: + return None + values, report = result + return values, { + **report, + "stages": 1, + "jit_stages": 1, + "interpreter_stages": 0, + "intermediate_bytes": 0, + "normalization_bytes": 0, + } + + +def scalar_descriptor(value): + """Lossless transport only: numerical construction/inference is native.""" + category = "typed_scalar" if isinstance(value, np.generic) else "weak" + if type(value) is bool or isinstance(value, np.bool_): + dtype, encoding, payload = "bool", "boolean", bool(value) + elif type(value) is int or isinstance(value, np.integer): + dtype = value.dtype.name if category == "typed_scalar" else "int64" + encoding, payload = "decimal", str(value) + elif type(value) is float or isinstance(value, np.floating): + dtype = value.dtype.name if category == "typed_scalar" else "float64" + if category == "weak" and not math.isfinite(value): + raise ValueError("Nonfinite plain scalar captures are not native-graph eligible") + encoding = "ieee754-hex" + payload = ( + (value.tobytes()[::-1] if sys.byteorder == "little" else value.tobytes()).hex() + if category == "typed_scalar" + else struct.pack(">d", value).hex() + ) + else: + raise ValueError("Native captures require real numeric scalars") + return {"dtype": dtype, "category": category, "encoding": encoding, "value": payload} + + +class GraphAdapter: + """Python syntax -> declarative nodes; no type/shape/reduction planning.""" + + def __init__(self, operands): + self.operands, self.arrays, self.nodes, self.bindings = operands, {}, [], {} + + def add(self, op, **payload): + index = len(self.nodes) + self.nodes.append({"id": index, "op": op, **payload}) + return index + + def reduction(self, name, value, options): + unknown = options.keys() - {"axis", "keepdims", "dtype", "initial", "where"} + if unknown: + raise ValueError(f"Unsupported native reduction keywords: {unknown}") + axis = options.get("axis") + axes = None if axis is None else list(axis) if isinstance(axis, (list, tuple)) else [axis] + initial = options.get("initial") + return self.add( + name, + args=[value], + axes=axes, + keepdims=options.get("keepdims", False), + dtype="auto" if options.get("dtype") is None else np.dtype(options["dtype"]).name, + initial=None if initial is None else scalar_descriptor(initial), + where=options.get("where"), + ) + + def visit(self, node): # noqa: C901 -- syntax dispatch, not semantic planning + import blosc2 + + if isinstance(node, ast.Name): + if node.id in self.bindings: + return self.bindings[node.id] + value = self.operands[node.id] + if type(value) in {np.ndarray, blosc2.NDArray}: + self.arrays[node.id] = value + result = self.add("input", name=node.id, dtype=np.dtype(value.dtype).name) + else: + result = self.add("constant", **scalar_descriptor(value)) + self.bindings[node.id] = result + return result + if isinstance(node, ast.Constant): + return self.add("constant", **scalar_descriptor(node.value)) + if isinstance(node, ast.UnaryOp): + if ( + isinstance(node.operand, ast.Constant) + and type(node.operand.value) in {int, float} + and isinstance(node.op, (ast.USub, ast.UAdd)) + ): + value = node.operand.value + return self.add( + "constant", **scalar_descriptor(-value if isinstance(node.op, ast.USub) else value) + ) + op = {ast.USub: "neg", ast.UAdd: "pos", ast.Invert: "invert", ast.Not: "not"}[type(node.op)] + return self.add(op, args=[self.visit(node.operand)]) + if isinstance(node, ast.BinOp): + op = { + ast.Add: "add", + ast.Sub: "sub", + ast.Mult: "mul", + ast.Div: "div", + ast.FloorDiv: "floordiv", + ast.Mod: "mod", + ast.Pow: "pow", + ast.BitAnd: "bitand", + ast.BitOr: "bitor", + ast.BitXor: "bitxor", + ast.LShift: "lshift", + ast.RShift: "rshift", + }[type(node.op)] + return self.add(op, args=[self.visit(node.left), self.visit(node.right)]) + if isinstance(node, ast.Compare): + if len(node.ops) != 1: + raise ValueError("Native chained comparisons require explicit Boolean operators") + op = {ast.Eq: "eq", ast.NotEq: "ne", ast.Lt: "lt", ast.LtE: "le", ast.Gt: "gt", ast.GtE: "ge"}[ + type(node.ops[0]) + ] + return self.add(op, args=[self.visit(node.left), self.visit(node.comparators[0])]) + if isinstance(node, ast.BoolOp): + result = self.visit(node.values[0]) + for value in node.values[1:]: + result = self.add( + "and" if isinstance(node.op, ast.And) else "or", args=[result, self.visit(value)] + ) + return result + if isinstance(node, ast.IfExp): + return self.add( + "select", args=[self.visit(node.test), self.visit(node.body), self.visit(node.orelse)] + ) + if isinstance(node, ast.Call): + from .utils import MINIEXPR_FUNCTION_ALIASES + + method = False + if isinstance(node.func, ast.Name): + name = node.func.id + elif isinstance(node.func, ast.Attribute): + name = node.func.attr + method = not ( + isinstance(node.func.value, ast.Name) and node.func.value.id in {"np", "numpy"} + ) + if method and name not in REDUCERS: + raise ValueError("Native graphs do not support arbitrary attributes or methods") + else: + raise ValueError("Unsupported native callable syntax") + name = MINIEXPR_FUNCTION_ALIASES.get(name, name) + if name in REDUCERS: + if (method and node.args) or (not method and len(node.args) != 1): + raise ValueError("Native reductions require one expression and keyword options") + value = self.visit(node.func.value if method else node.args[0]) + options = {} + for keyword in node.keywords: + if keyword.arg in options: + raise ValueError("Duplicate native reduction keyword") + options[keyword.arg] = ( + self.visit(keyword.value) + if keyword.arg == "where" + else ast.literal_eval(keyword.value) + ) + return self.reduction(name, value, options) + if node.keywords: + raise ValueError("Native elementwise functions do not accept keywords") + args = [self.visit(arg) for arg in node.args] + if name == "copy": + if len(args) != 1: + raise ValueError("Native copy requires exactly one value") + return args[0] + if name == "where": + return self.add("select", args=args) + if name in { + "bool", + "int8", + "int16", + "int32", + "int64", + "uint8", + "uint16", + "uint32", + "uint64", + "float32", + "float64", + }: + return self.add("cast", args=args, dtype=name) + return self.add("function", args=args, name=name) + raise ValueError(f"Unsupported native syntax: {type(node).__name__}") + + +def lower_native_graph(expr, *, jit=False, reduction_options=None, root_options=None, allow_output=False): + import blosc2 + + if type(expr) is not blosc2.LazyExpr: + raise TypeError("Native graph lowering requires a LazyExpr") + if any(hasattr(expr, name) for name in ("_where_args", "_indices", "_order")) or ( + not allow_output and hasattr(expr, "_output") + ): + raise ValueError("Table filtering, ordering and output aliases are not native-graph eligible") + if not reduction_options and not root_options: + prepared = getattr(expr, "_prepared_native", getattr(expr, "_metadata_native", None)) + if prepared is not None and prepared[0] == _native_plan_cache_key(expr, jit, {"_getitem": True}): + plan, names, reduction = prepared[1] + return plan, {name: expr.operands[name] for name in names}, reduction + graph = parse_expression(expr.expression) + operands = dict(expr.operands) + validate_operands(operands) + if graph.names - operands.keys(): + raise ValueError("Native graph contains unbound names") + configuration = _graph_configuration(jit) + text = _native_text_expression(graph.text) if not reduction_options and not root_options else None + arrays = {name: operands[name] for name in sorted(graph.names)} + if ( + text is not None + and arrays + and all(type(value) in (np.ndarray, blosc2.NDArray) for value in arrays.values()) + ): + source, reduction = text + signature = tuple((name, value.dtype.name) for name, value in arrays.items()) + plan = compile_plan(source, jit, configuration, input_dtypes=signature) + return plan, arrays, reduction + adapter = GraphAdapter(operands) + root = adapter.visit(ast.parse(graph.text, mode="eval").body) + if reduction_options: + options = dict(reduction_options) + root = adapter.reduction(options.pop("reduction"), root, options) + if root_options: + if adapter.nodes[root]["op"] not in REDUCERS: + raise ValueError("Root reduction options require a reduction graph") + if "initial" in root_options: + adapter.nodes[root]["initial"] = scalar_descriptor(root_options["initial"]) + document = { + "format": "menudet-graph-1", + "semantics": "menudet-numpy-1.0", + "requires": ["numeric", "staged"] + if any(node["op"] in REDUCERS and node["id"] != root for node in adapter.nodes) + else ["numeric"], + "nodes": adapter.nodes, + "root": root, + "output": {"dtype": "auto", "casting": "unsafe"}, + } + plan = compile_plan(json.dumps(document, sort_keys=True, separators=(",", ":")), jit, configuration) + return plan, adapter.arrays, adapter.nodes[root]["op"] in REDUCERS + + +def compute_native_graph( # noqa: C901 -- metadata-only selection and options preflight + expr, item=(), *, tile_items=1024, jit=False, prepared=None, parallel_reductions=False, **kwargs +): + import blosc2 + + # Preflight before input reads or any destination creation. + explicit = kwargs.pop("_reduce_args", None) + reduction_options = None + root_options = None + if explicit: + if explicit["op_str"] not in REDUCERS: + raise ValueError("Unsupported nested/native reduction") + reduction_options = { + "reduction": explicit["op_str"], + "axis": explicit.get("axis"), + "keepdims": explicit.get("keepdims", False), + "dtype": explicit.get("dtype"), + } + if "initial" in kwargs: + if reduction_options is None: + root_options = {"initial": kwargs.pop("initial")} + else: + reduction_options["initial"] = kwargs.pop("initial") + plan, inputs, reduction = ( + prepared + if prepared is not None + else lower_native_graph( + expr, jit=jit, reduction_options=reduction_options, root_options=root_options + ) + ) + getitem = kwargs.pop("_getitem", False) + output = kwargs.pop("out", None) + if output is not None and ( + not getitem + or not parallel_reductions + or (reduction and any(type(value) is blosc2.NDArray for value in inputs.values())) + ): + raise ValueError("Explicit native output requires an eligible map or resident reduction") + for key in ("_output", "out", "_ne_args", "ne_args", "_where_args", "_indices", "_order"): + if key in kwargs: + raise ValueError(f"{key} is not native-graph eligible") + kwargs.pop("_use_index", None) + if reduction and kwargs: + raise ValueError("Native reductions do not accept output/storage/backend overrides") + if ( + tile_items == 1024 + and not reduction + and all(type(value) is np.ndarray for value in inputs.values()) + and math.prod(expr.shape) < _MINIMUM_PARALLEL_ITEMS + ): + # Small resident maps avoid parallel scheduling; use fewer native tiles. + tile_items = 65536 + schedule = plan.specialize( + {name: (value.dtype, value.shape) for name, value in inputs.items()}, tile_items + ) + shape = schedule.info()["map_shape"] + selection = item if isinstance(item, tuple) else (item,) + if selection: + if plan.info()["stages"] > 1: + raise ValueError("Staged native graphs do not accept partial logical-domain reads") + if not inputs: + raise ValueError("Partial constant-only native graphs are not eligible") + if any(type(s) is not int and not isinstance(s, (slice, type(Ellipsis))) for s in selection): + raise ValueError("Native partial reads support only basic slices/integers") + if sum(s is Ellipsis for s in selection) > 1: + raise ValueError("Only one ellipsis is allowed") + if Ellipsis in selection: + pos = selection.index(Ellipsis) + selection = ( + selection[:pos] + (slice(None),) * (len(shape) - len(selection) + 1) + selection[pos + 1 :] + ) + if len(selection) > len(shape): + raise IndexError("Too many indices") + selection += (slice(None),) * (len(shape) - len(selection)) + if reduction: + raise ValueError("Native reduction partial reads are not yet eligible; select operands first") + if reduction and not selection and any(type(value) is blosc2.NDArray for value in inputs.values()): + streamed = ( + _parallel_compressed_reduction(plan, inputs, shape, tile_items) if parallel_reductions else None + ) + result, report = ( + evaluate_graph_sources(plan, inputs, tile_items=max(tile_items, 65536)) + if streamed is None + else streamed + ) + expr._native_execution_report = { + **report, + "semantic_revision": "menudet-numpy-1.0", + "backend": "portable-mixed" + if report["jit_stages"] and report["interpreter_stages"] + else "portable-jit" + if report["jit_stages"] + else "portable-interpreter", + "plan_cache": compile_plan.cache_info()._asdict(), + "frontend": getattr(plan, "_frontend", "declarative-json"), + } + return result + if ( + not reduction + and getitem + and parallel_reductions + and any(type(value) is blosc2.NDArray for value in inputs.values()) + and ( + not selection + or all( + isinstance(s, slice) and s.indices(n) == (0, n, 1) + for s, n in zip(selection, shape, strict=True) + ) + ) + ): + streamed = _parallel_compressed_map(plan, inputs, shape, tile_items, out=output) + if streamed is not None: + result, report = streamed + expr._native_execution_report = { + **report, + "semantic_revision": "menudet-numpy-1.0", + "backend": "portable-jit", + "plan_cache": compile_plan.cache_info()._asdict(), + "frontend": getattr(plan, "_frontend", "declarative-json"), + } + return result + arrays = {} + for name, value in inputs.items(): + if selection: + source_item = tuple( + slice(None) if n == 1 and isinstance(s, slice) else 0 if n == 1 else s + for n, s in zip(value.shape, selection[len(shape) - len(value.shape) :], strict=True) + ) + arrays[name] = np.asarray(value[source_item]) + else: + arrays[name] = value if isinstance(value, np.ndarray) else value[()] + if selection: + schedule = plan.specialize( + {name: (value.dtype, value.shape) for name, value in arrays.items()}, tile_items + ) + parallel = ( + _parallel_resident_graph(plan, inputs, shape, selection, reduction, out=output) + if tile_items == 1024 and (reduction or math.prod(shape) >= _MINIMUM_PARALLEL_ITEMS) + else None + ) + if reduction and parallel_reductions: + parallel = _parallel_resident_reduction(plan, arrays, shape, tile_items) + if parallel is None: + if ( + output is not None + and getattr(blosc2.blosc2_ext, "native_graph_output_available", lambda: False)() + ): + result, report = schedule.execute(arrays, out=output) + else: + result, report = schedule.execute(arrays) + else: + result, report = parallel + if output is not None and result is not output: + # Admission checked shape/dtype/layout and aliasing before any execution. + # Preserve the existing destination identity, without replaying kernels. + np.copyto(output, result, casting="no") + report = {**report, "output_copy_bytes": result.nbytes} + result = output + expr._native_execution_report = { + **report, + "semantic_revision": "menudet-numpy-1.0", + "backend": "portable-mixed" + if report["jit_stages"] and report["interpreter_stages"] + else "portable-jit" + if report["jit_stages"] + else "portable-interpreter", + "plan_cache": compile_plan.cache_info()._asdict(), + "frontend": getattr(plan, "_frontend", "declarative-json"), + "input_materialization_bytes": sum( + v.nbytes for k, v in arrays.items() if not isinstance(inputs[k], np.ndarray) + ), + } + if getitem or reduction: + return result + return blosc2.asarray(result, **kwargs) diff --git a/src/blosc2/ndarray.py b/src/blosc2/ndarray.py index 98ab50b0a..53d0bb19a 100644 --- a/src/blosc2/ndarray.py +++ b/src/blosc2/ndarray.py @@ -18,6 +18,7 @@ from contextlib import contextmanager from functools import reduce from itertools import islice, product +from operator import index from typing import TYPE_CHECKING, Any, NamedTuple, Protocol, runtime_checkable from numpy.exceptions import ComplexWarning @@ -56,8 +57,8 @@ # instead of materializing a huge coordinate set. _SUBSAMPLE_GATHER_MAX_COORDS = 1_000_000 -# These functions in ufunc_map in ufunc_map_1param are implemented in numexpr and so we call -# those instead (since numexpr uses multithreading it is faster) +# These ufuncs have expression equivalents; use native evaluation where admitted +# and explicit NumPy semantics otherwise. ufunc_map = { np.add: "+", np.subtract: "-", @@ -86,7 +87,7 @@ np.minimum: "minimum", } -# implemented in numexpr +# represented by the expression function registry ufunc_map_1param = { np.sqrt: "sqrt", np.sin: "sin", @@ -3372,7 +3373,7 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): _check_allowed_dtypes(value) return blosc2.LazyExpr(new_op=(value, ufunc_map_1param[ufunc], None)) - return NotImplemented # if not implemented in numexpr will default to NumPy + return NotImplemented # Unsupported expression ufuncs defer to NumPy. def __add__(self, value: int | float | blosc2.Array, /) -> blosc2.LazyExpr: _check_allowed_dtypes(value) @@ -4820,8 +4821,8 @@ def __setitem__( try: value = value.astype(self.dtype) except ComplexWarning: - # numexpr type inference can lead to unnecessary type promotions - # when using complex functions (e.g. conj) with real arrays + # Expression type inference can promote complex functions (e.g. + # conj) applied to real arrays; preserve the destination dtype. value = value.real.astype(self.dtype) result = super().set_slice((start, stop), value) @@ -5003,6 +5004,9 @@ def to_cframe(self) -> bytes: >>> print("Data type of the NDArray:", blosc_array.dtype) Data type of the NDArray: int32 """ + from blosc2.b2objects import preflight_persistence + + preflight_persistence(self) return super().to_cframe() def copy(self, dtype: np.dtype | str = None, **kwargs: Any) -> NDArray: @@ -5097,6 +5101,9 @@ def save(self, urlpath: str, contiguous=True, **kwargs: Any) -> None: >>> # Save the array to a file >>> a.save("array.b2frame") """ + from blosc2.b2objects import preflight_persistence + + preflight_persistence(self) urlpath = normalize_urlpath(urlpath) if is_fsspec_url(urlpath): if not contiguous: @@ -6168,15 +6175,113 @@ def ones( return full(shape, 1, dtype, **kwargs) -def arange( +def _menudet_ramp(start, step, dtype, shape, *, execution, partitions=None, endpoint_stop=None): + """Build an input-free Menudet ramp and bind it to a logical shape.""" + # Complex kernels have no JIT backend; use portable interpretation even + # when the caller requests JIT, as for the existing WASM ramp path. + if blosc2.IS_WASM or dtype.kind == "c": + execution = {**execution, "jit": False, "jit_backend": None} + + if ( + dtype == np.dtype(np.int64) + and isinstance(start, (int, np.integer)) + and isinstance(step, (int, np.integer)) + ): + start = int(start) + step = int(step) + elif dtype.kind == "c": + start = complex(start) + step = complex(step) + else: + start = float(start) + step = float(step) + + @blosc2.dsl_kernel + def ramp(start, step): + return start + _flat_idx * step # noqa: F821 + + if dtype.kind == "f": + ramp = blosc2.DSLKernel.from_source( + "def ramp(start, step):\n return float(start) + _flat_idx * float(step)\n" + ) + + constants = {"start": start, "step": step} + if endpoint_stop is not None: + # Avoid accumulated rounding at the endpoint, also for partial reads + # and rechunked materialization of a complex lazy linspace. + ramp = blosc2.DSLKernel.from_source( + "def ramp(start, step, stop, last):\n" + " if _flat_idx == last:\n" + " return stop\n" + " return start + _flat_idx * step\n" + ) + constants.update(stop=complex(endpoint_stop), last=math.prod(shape) - 1) + + backend = execution.get("jit_backend") + if backend in {"tcc", "cc"}: + ramp.dsl_source = f"# me:compiler={backend}\n" + ramp.dsl_source + artifact = ramp.export({}, dtype, constants=constants, ndim=len(shape)) + jit_option = execution.get("jit") + jit_mode = math.prod(shape) >= 4_000_000 if jit_option is None else bool(jit_option) + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit_mode) + return kernel.lazy({}, shape=shape, partitions=partitions) + + +def _menudet_ramp_supported(dtype, execution): + """Return whether portable ramp semantics/options match this constructor call.""" + if dtype not in ( + np.dtype(np.int64), + np.dtype(np.float32), + np.dtype(np.float64), + np.dtype(np.complex64), + np.dtype(np.complex128), + ): + return False + if execution.get("jit_backend") == "js": + return False + # PortableKernel currently consumes compiler policy from the artifact pragma, + # not every task-local C compiler/cache override. + if builtins.any(execution.get(name) for name in ("compiler", "cflags", "cache_dir", "compiler_output")): + return False + return execution.get("fp_accuracy", blosc2.FPAccuracy.DEFAULT) == blosc2.FPAccuracy.DEFAULT + + +def _compute_menudet_ramp(start, step, dtype, shape, execution, kwargs, *, endpoint_stop=None): + """Evaluate a Menudet ramp and materialize it into Blosc2 storage.""" + storage_kwargs = {key: value for key, value in kwargs.items() if key not in execution} + output = blosc2.empty(shape, dtype=dtype, **storage_kwargs) + kernel_lazy = _menudet_ramp( + start, + step, + dtype, + shape, + execution=execution, + partitions=output.chunks, + endpoint_stop=endpoint_stop, + ) + if blosc2.blosc2_ext.portable_prefilter_inputs_eligible({}, output=output): + kernel_lazy.kernel._handle.evaluate_prefilter({}, out=output) + return output + for origin in itertools.product(*(range(0, n, c) for n, c in zip(shape, output.chunks, strict=True))): + extent = tuple(builtins.min(c, n - o) for o, c, n in zip(origin, output.chunks, shape, strict=True)) + item = tuple(slice(o, o + e) for o, e in zip(origin, extent, strict=True)) + values = kernel_lazy.kernel.evaluate_block( + {}, block_shape=extent, logical_shape=shape, block_origin=origin + ) + output[item] = values + return output + + +def arange( # noqa: C901 start: int | float, stop: int | float | None = None, step: int | float | None = 1, dtype: np.dtype | str = None, shape: int | tuple | list | None = None, c_order: bool = True, + lazy: bool = False, **kwargs: Any, -) -> NDArray: +) -> NDArray | blosc2.LazyArray: """ Return evenly spaced values within a given interval. Due to rounding errors for chunkwise filling, may differ @@ -6204,12 +6309,18 @@ def arange( following the order of chunks in the array; this is more memory efficient, as it does not require an intermediate copy of the array. Default is C order. + lazy: bool + If True, return a deferred Menudet-backed :ref:`LazyArray` instead of + materializing it. Storage options are supplied later to ``compute()``. + The lazy route supports int64, float32/64 and complex64/128, and requires + C order. Complex output requires real bounds and steps and is interpreter-only. Other Parameters ---------------- jit: bool or None, optional - Execution policy for the DSL-backed ramp: None (default) inherits the - configured JIT policy (tries JIT with built-in defaults); True tries JIT, + Execution policy for the ramp: None (default) inherits the + configured JIT policy; unset uses interpretation below 4 million elements + and tries JIT for larger portable ramps. True tries JIT, and False disables it. Native compilation or allocation failure falls back quietly to the interpreter. See :ref:`JITOptions`. jit_backend: {"tcc", "cc", "js"} or None, optional @@ -6221,8 +6332,9 @@ def arange( Returns ------- - out: :ref:`NDArray` - A :ref:`NDArray` is returned. + out: :ref:`NDArray` or :ref:`LazyArray` + Returns an :ref:`NDArray` by default or a deferred :ref:`LazyArray` when + ``lazy=True``. Examples -------- @@ -6271,12 +6383,48 @@ def ramp_arange(start, step): ) dtype = _check_dtype(dtype) + if type(lazy) is not bool: + raise TypeError("lazy must be a bool") + + execution = blosc2.jit_config.execution_options() + execution.update(blosc2.jit_config.pop_execution_options(kwargs)) + storage_kwargs = kwargs.copy() + if lazy: + if storage_kwargs: + raise TypeError("Storage options for a lazy arange belong on the returned array's compute()") + if not c_order: + raise NotImplementedError("lazy=True currently requires C-order arange traversal") + if is_inside_new_expr(): + raise ValueError("lazy=True cannot be used while building another lazy expression") + if not _menudet_ramp_supported(dtype, execution): + raise NotImplementedError( + "lazy=True requires an int64, float32, or float64 Menudet ramp, or complex64/128" + ) + return _menudet_ramp(start, step, dtype, tuple(shape), execution=execution) + if is_inside_new_expr() or NUM == 0: # We already have the dtype and shape, so return immediately - blosc2.jit_config.pop_execution_options(kwargs) - return blosc2.zeros(shape, dtype=dtype, **kwargs) + return blosc2.zeros(shape, dtype=dtype, **storage_kwargs) + + kwargs.update(execution) + + # Avoid compilation latency for small one-shot ramps unless explicitly requested. + if execution["jit"] is None: + execution["jit"] = NUM >= 4_000_000 + if c_order and _menudet_ramp_supported(dtype, execution): + if dtype == np.dtype(np.int64): + valid_int = ( + isinstance(start, (int, np.integer)) + and isinstance(step, (int, np.integer)) + and np.iinfo(np.int64).min <= start <= np.iinfo(np.int64).max + and np.iinfo(np.int64).min <= step <= np.iinfo(np.int64).max + ) + if valid_int: + return _compute_menudet_ramp(start, step, dtype, tuple(shape), execution, kwargs) + else: + return _compute_menudet_ramp(start, step, dtype, tuple(shape), execution, kwargs) - # Windows and wasm32 does not support complex numbers in DSL + # Retain the legacy path for insertion order or unsupported execution options. if blosc2.isdtype(dtype, "complex floating"): lshape = (math.prod(shape),) lazyarr = blosc2.lazyudf(arange_fill, (start, stop, step), dtype=dtype, shape=lshape) @@ -6285,14 +6433,14 @@ def ramp_arange(start, step): # C order is guaranteed, and no reshape is needed return lazyarr.compute(**kwargs) - return reshape(lazyarr, shape, c_order=c_order, **kwargs) + return reshape(lazyarr, shape, c_order=c_order, **storage_kwargs) else: lazyarr = blosc2.lazyudf(ramp_arange, (start, step), dtype=dtype, shape=shape) return lazyarr.compute(**kwargs) # Define a numpy linspace-like function -def linspace( +def linspace( # noqa: C901 start: int | float | complex, stop: int | float | complex, num: int | None = None, @@ -6300,8 +6448,9 @@ def linspace( endpoint: bool = True, shape=None, c_order: bool = True, + lazy: bool = False, **kwargs: Any, -) -> NDArray: +) -> NDArray | blosc2.LazyArray: """Return evenly spaced numbers over a specified interval. This is similar to `numpy.linspace` but it returns a `NDArray` @@ -6329,14 +6478,20 @@ def linspace( following the order of chunks in the array; this is more memory efficient, as it does not require an intermediate copy of the array. Default is True. + lazy: bool + If True, return a deferred Menudet-backed :ref:`LazyArray` instead of + materializing it. Storage options are supplied later to ``compute()``. + The lazy route supports float32/64 and complex64/128, and requires C order. + Complex ramps are interpreter-only, even when JIT is requested. **kwargs: Any Storage arguments accepted by :func:`empty`, plus the execution options below. Other Parameters ---------------- jit: bool or None, optional - Execution policy for the DSL-backed ramp: None (default) inherits the - configured JIT policy (tries JIT with built-in defaults); True tries JIT, + Execution policy for the ramp: None (default) inherits the + configured JIT policy; unset uses interpretation below 4 million elements + and tries JIT for larger portable ramps. True tries JIT, and False disables it. Native compilation or allocation failure falls back quietly to the interpreter. See :ref:`JITOptions`. jit_backend: {"tcc", "cc", "js"} or None, optional @@ -6346,8 +6501,9 @@ def linspace( Returns ------- - out: :ref:`NDArray` - A :ref:`NDArray` is returned. + out: :ref:`NDArray` or :ref:`LazyArray` + Returns an :ref:`NDArray` by default or a deferred :ref:`LazyArray` when + ``lazy=True``. """ def linspace_fill(inputs, output, offset): @@ -6393,12 +6549,48 @@ def ramp_linspace(start, step): dtype = _check_dtype(dtype) + if type(lazy) is not bool: + raise TypeError("lazy must be a bool") + + nitems = num - 1 if endpoint else num + if dtype.kind == "c": + step = (complex(stop) - complex(start)) / nitems if nitems > 0 else 0j + else: + step = (float(stop) - float(start)) / float(nitems) if nitems > 0 else 0.0 + endpoint_stop = stop if dtype.kind == "c" and endpoint and num > 1 else None + + execution = blosc2.jit_config.execution_options() + execution.update(blosc2.jit_config.pop_execution_options(kwargs)) + storage_kwargs = kwargs.copy() + if lazy: + if storage_kwargs: + raise TypeError("Storage options for a lazy linspace belong on the returned array's compute()") + if not c_order: + raise NotImplementedError("lazy=True currently requires C-order linspace traversal") + if is_inside_new_expr(): + raise ValueError("lazy=True cannot be used while building another lazy expression") + if dtype.kind not in "fc" or not _menudet_ramp_supported(dtype, execution): + raise NotImplementedError( + "lazy=True requires a float32/64 or complex64/128 Menudet ramp for linspace" + ) + return _menudet_ramp( + start, step, dtype, tuple(shape), execution=execution, endpoint_stop=endpoint_stop + ) + if is_inside_new_expr() or num == 0: # We already have the dtype and shape, so return immediately - blosc2.jit_config.pop_execution_options(kwargs) - return blosc2.zeros(shape, dtype=dtype, **kwargs) # will return empty array for num == 0 + return blosc2.zeros(shape, dtype=dtype, **storage_kwargs) # will return empty array for num == 0 + + kwargs.update(execution) + + if execution["jit"] is None: + execution["jit"] = num >= 4_000_000 + if c_order and _menudet_ramp_supported(dtype, execution): + return _compute_menudet_ramp( + start, step, dtype, tuple(shape), execution, kwargs, endpoint_stop=endpoint_stop + ) - # Windows and wasm32 does not support complex numbers in DSL + # Retain the legacy path for insertion order or unsupported execution options. if blosc2.isdtype(dtype, "complex floating"): inputs = (start, stop, num, endpoint) lazyarr = blosc2.lazyudf(linspace_fill, inputs, dtype=dtype, shape=(num,)) @@ -6406,10 +6598,8 @@ def ramp_linspace(start, step): # C order is guaranteed, and no reshape is needed return lazyarr.compute(**kwargs) - return reshape(lazyarr, shape, c_order=c_order, **kwargs) + return reshape(lazyarr, shape, c_order=c_order, **storage_kwargs) else: - nitems = num - 1 if endpoint else num - step = (float(stop) - float(start)) / float(nitems) if nitems > 0 else 0.0 inputs = (start, step) lazyarr = blosc2.lazyudf(ramp_linspace, inputs, dtype=dtype, shape=shape) return lazyarr.compute(**kwargs) @@ -6431,6 +6621,18 @@ def eye(N, M=None, k=0, dtype=np.float64, **kwargs: Any) -> NDArray: dtype: np.dtype or list str The data type of the array elements in NumPy format. Default is `np.float64`. + Other Parameters + ---------------- + jit: bool or None, optional + For portable numeric kernels, try JIT by default; False selects the + interpreter. Compilation failure falls back to interpretation. + jit_backend: str or None, optional + Select the native compiler ("tcc" or "cc"). + **kwargs: Any + Storage arguments accepted by :func:`empty`. Default chunk and block + shapes localize the diagonal so zero-only blocks skip kernel evaluation. + Complex output and WebAssembly retain the chunkwise NumPy callback. + Returns ------- out: :ref:`NDArray` @@ -6452,15 +6654,59 @@ def fill_eye(inputs, output: np.array, offset: tuple): if M is None: M = N - shape = (N, M) + shape = (index(N), index(M)) + k = index(k) dtype = _check_dtype(dtype) if is_inside_new_expr(): # We already have the dtype and shape, so return immediately return blosc2.zeros(shape, dtype=dtype) - lazyarr = blosc2.lazyudf(fill_eye, (k,), dtype=dtype, shape=shape) - return lazyarr.compute(**kwargs) + execution = blosc2.jit_config.execution_options() + execution.update(blosc2.jit_config.pop_execution_options(kwargs)) + # Portable numeric kernels do not yet support complex output. + if 0 in shape: + return blosc2.empty(shape, dtype=dtype, **kwargs) + if k >= shape[1] or k <= -shape[0]: + return blosc2.zeros(shape, dtype=dtype, **kwargs) + if ( + dtype.kind not in "biuf" + or not dtype.isnative + or (dtype.kind == "f" and dtype.itemsize not in (4, 8)) + or blosc2.IS_WASM + or execution.get("jit_backend") == "js" + ): + lazyarr = blosc2.lazyudf(fill_eye, (k,), dtype=dtype, shape=shape) + return lazyarr.compute(**kwargs) + + @blosc2.dsl_kernel + def diagonal(k): + return _i1 - _i0 == k # noqa: F821 + + backend = execution.get("jit_backend") + if backend in {"tcc", "cc"}: + diagonal.dsl_source = f"# me:compiler={backend}\n" + diagonal.dsl_source + artifact = diagonal.export({}, dtype, constants={"k": k}, ndim=2) + kernel = blosc2.PortableKernel.from_json(artifact, jit=execution.get("jit")) + # Square blocks localize the diagonal. Row-wide default blocks would all + # intersect it, preventing the scheduler from skipping zero-only blocks. + if kwargs.get("chunks") is None: + kwargs["chunks"] = tuple(builtins.min(1024, builtins.max(1, n)) for n in shape) + if kwargs.get("blocks") is None: + kwargs["blocks"] = tuple(builtins.min(128, c) for c in kwargs["chunks"]) + output = blosc2.empty(shape, dtype=dtype, **kwargs) + if not output.size: + return output + if blosc2.blosc2_ext.portable_prefilter_inputs_eligible({}, output=output): + kernel._handle.evaluate_prefilter({}, out=output, _diagonal=k) + return output + for origin in itertools.product(*(range(0, n, c) for n, c in zip(shape, output.chunks, strict=True))): + extent = tuple(builtins.min(c, n - o) for o, c, n in zip(origin, output.chunks, shape, strict=True)) + item = tuple(slice(o, o + e) for o, e in zip(origin, extent, strict=True)) + output[item] = kernel.evaluate_block( + {}, block_shape=extent, logical_shape=shape, block_origin=origin + ) + return output def fromiter(iterable, shape, dtype, c_order=True, **kwargs) -> NDArray: diff --git a/src/blosc2/portable_kernel.py b/src/blosc2/portable_kernel.py new file mode 100644 index 000000000..c069a4379 --- /dev/null +++ b/src/blosc2/portable_kernel.py @@ -0,0 +1,787 @@ +####################################################################### +# Copyright (c) 2026, Blosc Development Team +# SPDX-License-Identifier: BSD-3-Clause +####################################################################### +"""Menudet authoring and native-only execution (draft descriptors when installed).""" + +from __future__ import annotations + +import ast +import builtins +import json +import math +import os +import tokenize +from collections.abc import Mapping +from io import StringIO +from types import FunctionType, MappingProxyType + +import numpy as np + + +class PortableArtifactError(ValueError): + """Artifact failure with a stable category and optional native/source diagnostics.""" + + def __init__(self, message, *, status, native_status=0, line=0, column=0): + self.status = status + self.native_status = native_status + self.line = line + self.column = column + location = f" at line {line}, column {column}" if line else "" + super().__init__(f"{status}{location}: {message}") + + +# Native numeric byte orders key the common dtype descriptor without dtype.name. +_NATIVE_DTYPE_NAMES = { + np.dtype(name).str: name + for name in ( + "bool", + "int8", + "int16", + "int32", + "int64", + "uint8", + "uint16", + "uint32", + "uint64", + "float32", + "float64", + "complex64", + "complex128", + ) +} + + +def _mapping(value, label): + if not isinstance(value, Mapping): + raise TypeError(f"{label} must be a mapping") + if any(not isinstance(name, str) or not name or "\x00" in name for name in value): + raise ValueError(f"{label} names must be nonempty strings without NUL characters") + return dict(value) + + +def portable_dtype_descriptor(value): + if type(value) is np.dtype: + dtype = value + else: + dtype = np.dtype(value) + if dtype.isnative and dtype.metadata is None: + name = _NATIVE_DTYPE_NAMES.get(dtype.str) + if name is not None: + return {"dtype": name} + dtype = dtype.newbyteorder("=") + if ( + dtype.fields + or dtype.subdtype + or dtype.kind not in "biufcSU" + or (dtype.kind == "f" and dtype.itemsize not in (4, 8)) + or (dtype.kind == "c" and dtype.itemsize not in (8, 16)) + ): + raise PortableArtifactError(f"Unsupported portable dtype {dtype}", status="unsupported_requirement") + if dtype.kind in "SU": + if not dtype.itemsize: + raise PortableArtifactError("Fixed strings require a positive width", status="binding_error") + return {"dtype": "bytes" if dtype.kind == "S" else "unicode32", "itemsize": dtype.itemsize} + return {"dtype": dtype.name} + + +def portable_scalar_descriptor(name, value, dtype=None): # noqa: C901 -- per-dtype encoding matrix + numeric = ( + bool, + int, + float, + np.bool_, + np.int8, + np.int16, + np.int32, + np.int64, + np.uint8, + np.uint16, + np.uint32, + np.uint64, + np.float32, + np.float64, + complex, + np.complex64, + np.complex128, + ) + if type(value) not in numeric + (str, bytes, np.str_, np.bytes_): + raise PortableArtifactError("Captures must be plain numeric/string scalars", status="binding_error") + if dtype is None: + dtype = {bool: "bool", int: "int64", float: "float64"}.get(type(value), np.asarray(value).dtype) + descriptor = portable_dtype_descriptor(dtype) + dtype = np.dtype(dtype).newbyteorder("=") + if dtype.kind in "SU": + if (dtype.kind == "S" and type(value) not in (bytes, np.bytes_)) or ( + dtype.kind == "U" and type(value) not in (str, np.str_) + ): + raise PortableArtifactError("String capture family mismatch", status="binding_error") + if len(value) > dtype.itemsize // (4 if dtype.kind == "U" else 1): + raise PortableArtifactError("String capture exceeds its fixed width", status="binding_error") + if dtype.kind == "U" and any(0xD800 <= ord(c) <= 0xDFFF for c in value): + raise PortableArtifactError("Invalid Unicode scalar", status="binding_error") + encoded = np.asarray(value, dtype=dtype).astype(dtype.newbyteorder(">"), copy=False).tobytes().hex() + return { + "name": name, + **descriptor, + "encoding": "bytes-hex" if dtype.kind == "S" else "unicode32be-hex", + "value": encoded, + } + if dtype.kind in "biu": + if type(value) in (float, np.float32, np.float64, str, bytes, np.str_, np.bytes_): + raise PortableArtifactError("Integral captures require integral values", status="binding_error") + integer = int(value) + lower, upper = (0, 1) if dtype.kind == "b" else (np.iinfo(dtype).min, np.iinfo(dtype).max) + if not lower <= integer <= upper: + raise PortableArtifactError("Capture is outside its dtype", status="binding_error") + return { + "name": name, + **descriptor, + "encoding": "boolean" if dtype.kind == "b" else "decimal", + "value": bool(integer) if dtype.kind == "b" else str(integer), + } + if type(value) in (str, bytes, np.str_, np.bytes_): + raise PortableArtifactError("Numeric capture family mismatch", status="binding_error") + if dtype.kind == "c": + if isinstance(value, np.complexfloating) and np.dtype(type(value)) != dtype: + raise PortableArtifactError( + "Complex capture dtype disagrees with its declaration", status="binding_error" + ) + if not isinstance(value, int | float | complex | np.number) or isinstance(value, bool): + raise PortableArtifactError("Complex captures require numeric values", status="binding_error") + scalar = np.asarray(value, dtype=dtype) + # Two big-endian components: real then imaginary. + return { + "name": name, + **descriptor, + "encoding": "ieee754-hex", + "value": scalar.astype(dtype.newbyteorder(">"), copy=False).tobytes().hex(), + } + integral = type(value) in ( + bool, + int, + np.bool_, + np.int8, + np.int16, + np.int32, + np.int64, + np.uint8, + np.uint16, + np.uint32, + np.uint64, + ) + # NumPy signed minima cannot be negated in their own fixed-width dtype. + magnitude = abs(int(value)) if integral else abs(float(value)) + if (integral or math.isfinite(value)) and magnitude > float(np.finfo(dtype).max): + raise PortableArtifactError("Floating capture overflows its dtype", status="binding_error") + scalar = np.asarray(value, dtype=dtype) + return { + "name": name, + **descriptor, + "encoding": "ieee754-hex", + "value": scalar.astype(dtype.newbyteorder(">"), copy=False).tobytes().hex(), + } + + +def _parameterize_source(source, replacements, parameters): + """Token edits retain comments/pragmas and never edit strings or substrings.""" + if not replacements and not parameters: + return source + tokens = list(tokenize.generate_tokens(StringIO(source).readline)) + starts = [0] + for line in source.splitlines(keepends=True): + starts.append(starts[-1] + len(line)) + + def offset(position): + return starts[position[0] - 1] + position[1] + + edits = [] + depth = 0 + signature = False + for token in tokens: + if token.type == tokenize.NAME and token.string == "def": + signature = True + if signature and token.string == "(": + depth += 1 + elif signature and token.string == ")": + depth -= 1 + if depth == 0: + if parameters: + edits.append((offset(token.start), offset(token.start), ", ".join(parameters))) + signature = False + elif token.type == tokenize.NAME and token.string in replacements and not signature: + edits.append((offset(token.start), offset(token.end), replacements[token.string])) + for start, end, text in sorted(edits, reverse=True): + source = source[:start] + text + source[end:] + return source + + +def _capture_scope(func): + if not isinstance(func, FunctionType): + raise PortableArtifactError( + "Only ordinary Python functions can export captures", status="unsupported_requirement" + ) + scope = func.__globals__.copy() + for name, cell in zip(func.__code__.co_freevars, func.__closure__ or (), strict=True): + try: + scope[name] = cell.cell_contents + except ValueError as error: + raise PortableArtifactError(f"Unbound capture {name!r}", status="invalid_source") from error + return scope + + +def capture_analysis(source, names): + """Analyze fixed author syntax without resolving or validating captures.""" + tree = ast.parse(source) + function = next(node for node in tree.body if isinstance(node, ast.FunctionDef)) + nodes = tuple(ast.walk(function)) + local = set(names) | { + node.id for node in nodes if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store) + } + calls = { + node.func.id for node in nodes if isinstance(node, ast.Call) and isinstance(node.func, ast.Name) + } + loads = {node.id for node in nodes if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load)} + return function, nodes, local, calls, loads + + +def _export_captures(func, source, names, capture_dtypes, version="1.0", *, analysis=None): + scope = _capture_scope(func) + function, nodes, local, calls, loads = capture_analysis(source, names) if analysis is None else analysis + # Native compilation owns builtin membership. Never export external callbacks. + if any(isinstance(n, (ast.Attribute, ast.Subscript, ast.Lambda)) for n in nodes): + raise PortableArtifactError("Unsupported dynamic authoring syntax", status="unsupported_requirement") + for call in calls: + # Module __getattr__ can warn for removed/renamed NumPy aliases (np.bool). + # Membership here must stay a quiet dictionary lookup. + allowed = (vars(builtins).get(call), vars(np).get(call), vars(math).get(call)) + if call in local or (call in scope and not any(v is not None and scope[call] is v for v in allowed)): + raise PortableArtifactError( + f"External callback {call!r} cannot be exported", status="unsupported_requirement" + ) + occupied = local | loads | {function.name} + replacements = {} + encoded = [] + for name in sorted(loads - local - calls): + if name in {"_flat_idx", "_ndim"} or (name.startswith(("_i", "_n")) and name[2:].isdigit()): + continue + if name not in scope: + node = next(node for node in nodes if isinstance(node, ast.Name) and node.id == name) + raise PortableArtifactError( + f"Unresolved capture {name!r}", + status="invalid_source", + line=node.lineno, + column=node.col_offset + 1, + ) + index = len(replacements) + candidate = f"_capture_{index}" + while candidate in occupied: + index += 1 + candidate = f"_capture_{index}" + occupied.add(candidate) + scalar = portable_scalar_descriptor(name, scope[name], capture_dtypes.get(name)) + if version == "1.0" and scalar["dtype"] not in {"bytes", "unicode32"}: + scalar["category"] = ( + "weak" + if type(scope[name]) in (bool, int, float) and name not in capture_dtypes + else "typed_scalar" + ) + scalar["name"] = candidate + encoded.append(scalar) + replacements[name] = candidate + added = list(replacements.values()) + if names and added: + added[0] = ", " + added[0] + return ( + _parameterize_source(source, replacements, added), + encoded, + set(replacements) & set(capture_dtypes), + ) + + +def _header_pragmas(source): + """Return recognized header pragmas without inventing environment defaults.""" + values = {} + for line in source.splitlines(): + stripped = line.strip() + if not stripped: + continue + if not stripped.startswith("#"): + break + body = stripped[1:].strip() + if not body.startswith("me:"): + continue + key, separator, value = body[3:].partition("=") + key, value = key.strip(), value.strip() + if separator and key in {"fp", "math", "ulp"}: + values[key] = value + return values + + +def _artifact_semantics(source, version, casting): + """Build validated semantic fields while leaving omissions as inheritance.""" + pragmas = _header_pragmas(source) + semantics = {**({"numeric": "numpy-2.5", "casting": casting} if version == "1.0" else {})} + requires = ["numeric", "control-flow", "block-reductions", "fixed-strings", "nd-context"] + if "fp" in pragmas: + semantics["fp"] = pragmas["fp"] + if "math" in pragmas: + semantics["math"] = pragmas["math"] + if "ulp" in pragmas: + semantics["ulp"] = pragmas["ulp"] + if "math" in pragmas or "ulp" in pragmas or semantics.get("fp", "strict") != "strict": + requires.append("flexible-math") + return semantics, requires + + +def export_portable_kernel(kernel, input_dtypes, output_dtype, **options): + """Implementation of :meth:`blosc2.DSLKernel.export`; does not call the kernel.""" + return prepare_portable_kernel(kernel, input_dtypes, output_dtype, **options).to_json() + + +def prepare_portable_kernel( + kernel, + input_dtypes, + output_dtype=None, + *, + capture_dtypes=None, + constants=None, + metadata=None, + version="1.0", + casting="unsafe", + cardinality="elementwise", + ndim=0, + jit=False, +): + """Build and import once, retaining native validation for export and specialization. + + ``output_dtype=None`` requests metadata-only native result inference under the + declared input signatures and casting policy. The returned kernel retains an + artifact text with the inferred concrete output dtype. + """ + if version != "1.0": + raise PortableArtifactError("Unsupported artifact version", status="unsupported_version") + if casting not in {"safe", "same_kind", "unsafe"}: + raise PortableArtifactError("Unsupported Menudet casting policy", status="unsupported_requirement") + inputs = _mapping(input_dtypes, "input_dtypes") + constants = _mapping({} if constants is None else constants, "constants") + captures = _mapping({} if capture_dtypes is None else capture_dtypes, "capture_dtypes") + source = kernel.dsl_source + if not isinstance(source, str): + raise PortableArtifactError("Kernel has no normalized source", status="invalid_source") + names = kernel.input_names + if set(inputs) & set(constants) or set(inputs) | set(constants) != set(names): + raise PortableArtifactError( + "Every parameter needs exactly one input or constant binding", status="binding_error" + ) + encoded = [ + portable_scalar_descriptor(name, value, captures.get(name)) for name, value in constants.items() + ] + if version == "1.0": + for scalar, (name, value) in zip(encoded, constants.items(), strict=True): + if scalar["dtype"] not in {"bytes", "unicode32"}: + scalar["category"] = ( + "weak" if type(value) in (bool, int, float) and name not in captures else "typed_scalar" + ) + used = set(constants) & set(captures) + if kernel.func is not None: + source, captured, extra = _export_captures( + kernel.func, + source, + names, + captures, + version, + analysis=getattr(kernel, "_capture_analysis", None), + ) + encoded.extend(captured) + used |= extra + if set(captures) - used: + raise PortableArtifactError("Unused capture dtype names", status="binding_error") + if cardinality not in {"elementwise", "block_scalar"} or type(ndim) is not int or ndim < 0: + raise PortableArtifactError("Invalid return/context contract", status="binding_error") + if metadata is not None and not isinstance(metadata, Mapping): + raise TypeError("metadata must be a mapping") + # This finite superset grants no unsupported operations: native typed import + # validates the entire normalized source before this export can succeed. + semantics, requires = _artifact_semantics(source, version, casting) + manifest = { + "schema_version": version, + "language": {"name": "miniexpr", "version": version}, + "requires": requires, + "source": source, + "entry_point": kernel.__name__, + "inputs": [ + {"name": name, **portable_dtype_descriptor(inputs[name])} for name in names if name in inputs + ], + "constants": sorted(encoded, key=lambda item: item["name"]), + "output": ( + {**portable_dtype_descriptor(output_dtype), "contract": cardinality} + if output_dtype is not None + else {"dtype": "auto", "contract": cardinality} + ), + "semantics": semantics, + "context": {"ndim": ndim}, + "metadata": dict(metadata or {}), + } + artifact = ( + json.dumps(manifest, sort_keys=True, ensure_ascii=False, allow_nan=False, separators=(",", ":")) + + "\n" + ) + if output_dtype is not None: + return PortableKernel.from_json(artifact, jit=jit) + try: + return PortableKernel.from_json(artifact, jit=jit, infer_output=True) + except NotImplementedError: + return _prepare_inferred_fallback( + kernel, + input_dtypes, + capture_dtypes=capture_dtypes, + constants=constants, + metadata=metadata, + version=version, + casting=casting, + cardinality=cardinality, + ndim=ndim, + jit=jit, + ) + + +def _prepare_inferred_fallback( + kernel, + input_dtypes, + *, + capture_dtypes, + constants, + metadata, + version, + casting, + cardinality, + ndim, + jit, +): + """Infer through a float64 probe when the native auto-output loader is absent.""" + probe = prepare_portable_kernel( + kernel, + input_dtypes, + "float64", + capture_dtypes=capture_dtypes, + constants=constants, + metadata=metadata, + version=version, + casting=casting, + cardinality=cardinality, + ndim=ndim, + jit=jit, + ) + output = probe.inferred_dtype + if output is None: + raise PortableArtifactError( + "Native output inference is unavailable", status="unsupported_requirement" + ) from None + if output == probe.output_dtype: + return probe + return PortableKernel.from_json(_artifact_with_output(probe.to_json(), output), jit=jit) + + +def _artifact_with_output(artifact, output_dtype): + """Resolve an inferred output dtype in retained artifact text without reimport.""" + manifest = json.loads(artifact) + manifest["output"].update(portable_dtype_descriptor(output_dtype)) + encoded = json.dumps( + manifest, sort_keys=True, ensure_ascii=False, allow_nan=False, separators=(",", ":") + ) + return (encoded + "\n").encode("utf-8") + + +class PortableKernel: + """An owned, typed native artifact; no originating function or Python fallback. + + Use ``from_json`` to import and ``evaluate`` to return NumPy values. Inputs + are same-shaped logical arrays, bound by name. The installed native adapter + enforces its supported profiles. Draft 1.0 descriptor blocks are available + only when that runtime exposes the extended ABI; no sibling build is inferred. + """ + + @classmethod + def from_json(cls, artifact, *, jit=None, infer_output=False): + from . import blosc2_ext, jit_config + + if not isinstance(artifact, str | bytes): + raise TypeError("artifact must be JSON text or UTF-8 bytes, not a path or decoded mapping") + if jit is not None and type(jit) is not bool: + raise TypeError("jit must be True, False, or None") + if type(infer_output) is not bool: + raise TypeError("infer_output must be a bool") + handle_type = getattr(blosc2_ext, "PortableArtifactHandle", None) + if handle_type is None: + raise NotImplementedError("Build with miniexpr portable artifact support") + try: + data = artifact.encode("utf-8") if isinstance(artifact, str) else artifact + except UnicodeEncodeError as error: + raise PortableArtifactError( + "Artifact text must be valid UTF-8", status="invalid_artifact" + ) from error + policy = jit_config.execution_options()["jit"] if jit is None else jit + if policy is None and os.environ.get("BLOSC_ME_JIT", "").lower() in ("1", "true", "on", "tcc", "cc"): + policy = True + mode = ( + getattr(blosc2_ext, "portable_auto_jit_mode", lambda: 0)() + if policy is None + else 1 + if policy + else 2 + ) + if infer_output: + handle = handle_type(data, mode, True) + else: + handle = handle_type(data, mode) + instance = cls.__new__(cls) + instance._handle = handle + instance._expression_handle = handle + instance._info = handle.info() + if getattr(blosc2_ext, "portable_descriptor_available", lambda: False)(): + instance._info.update(handle.descriptor_info()) + if infer_output: + data = _artifact_with_output(data, instance._info["output_dtype"]) + instance._artifact = data + instance._expression_artifact = data + return instance + + @property + def source(self): + return self._info["source"] + + @property + def entry_point(self): + return self._info["entry_point"] + + @property + def input_dtypes(self): + return MappingProxyType(self._info["inputs"]) + + @property + def output_dtype(self): + return self._info["output_dtype"] + + @property + def inferred_dtype(self): + """Metadata-only result dtype before final conversion (Menudet 1.0 runtime required).""" + return self._info.get("inferred_dtype") + + @property + def has_jit(self): + return self._info["jit"] + + @property + def execution_kind(self): + """Native structural classification: expression, program, or unknown on older runtimes.""" + return self._info.get("execution_kind", "unknown") + + @property + def schema_version(self): + return self._info.get("schema_version", "1.0") + + @property + def result_cardinality(self): + return self._info.get("cardinality", "elementwise") + + @property + def context_ndim(self): + return self._info.get("ndim", 0) + + def to_json(self): + """Return the original validated JSON text, without dropping metadata.""" + return self._artifact.decode("utf-8") + + def evaluate(self, inputs, *, shape=None, return_status=False, fp_errors="ignore"): + """Evaluate named arrays into a new NumPy array, preserving their common shape. + + No implicit dtype conversion or array broadcasting is allowed. Host endian, + alignment, and strides are normalized into temporary contiguous buffers. + Constant-only kernels require an explicit output ``shape`` (possibly empty). + Draft block-scalar kernels return a scalar NumPy array. ND kernels require + ``evaluate_block`` with explicit logical context. + Menudet 1.0 can return ``(values, status)`` with ``return_status=True``. + Status has stable ``flags`` bits (invalid=1, divide=2, overflow=4, + underflow=8) and a ``supported`` capability. ``fp_errors='raise'`` raises + for any of these flags; the default ``'ignore'`` emits no warnings. + """ + inputs = _mapping(inputs, "inputs") + if set(inputs) != set(self.input_dtypes): + raise PortableArtifactError("Missing or extra runtime inputs", status="binding_error") + if shape is not None: + if isinstance(shape, int): + shape = (shape,) + else: + shape = tuple(shape) + if any(type(size) is not int or size < 0 for size in shape): + raise ValueError("shape must contain nonnegative Python integers") + arrays = {} + for name, value in inputs.items(): + array = np.asarray(value) + dtype = self.input_dtypes[name] + if array.dtype.newbyteorder("=") != dtype: + raise PortableArtifactError( + f"Input {name!r} must have dtype {dtype}, not {array.dtype}", status="binding_error" + ) + if shape is None: + shape = array.shape + if array.shape != shape: + raise PortableArtifactError( + "All input shapes must match the output shape", status="binding_error" + ) + arrays[name] = np.require(array, dtype=dtype, requirements=["C", "A"]) + if shape is None: + raise ValueError("Constant-only kernels require an explicit shape") + if self.context_ndim: + raise ValueError( + "Use evaluate_block with explicit logical_shape and block_origin for ND artifacts" + ) + return self.evaluate_block( + arrays, block_shape=shape, return_status=return_status, fp_errors=fp_errors + ) + + def evaluate_block( + self, + inputs, + *, + block_shape=None, + logical_shape=None, + block_origin=None, + valid_mask=None, + return_status=False, + fp_errors="ignore", + _validated=False, + ): + """Evaluate one explicit draft 1.0 block, returning its declared cardinality. + + This is standalone block execution, not lazy block-grid scheduling. Native + validation owns coordinates, participating masks and result allocation. + Floating status is per call, includes only evaluated active operations, + and must be aggregated explicitly by callers across blocks. This is not + full ``numpy.seterr`` emulation. + """ + if self.schema_version != "1.0": + raise NotImplementedError("Explicit descriptor blocks require an installed draft 1.0 runtime") + if _validated: + # Callers with exact resident buffers keep native validation and + # allocation but skip repeated Python-side binding checks. + return self._handle.evaluate_block( + inputs, + block_shape, + logical_shape=logical_shape, + block_origin=block_origin, + valid_mask=valid_mask, + return_status=return_status, + fp_raise=15 if fp_errors == "raise" else 0, + ) + inputs = _mapping(inputs, "inputs") + if set(inputs) != set(self.input_dtypes): + raise PortableArtifactError("Missing or extra runtime inputs", status="binding_error") + if isinstance(block_shape, int): + block_shape = (block_shape,) + elif block_shape is not None: + block_shape = tuple(block_shape) + if block_shape is not None and any(type(size) is not int or size < 0 for size in block_shape): + raise ValueError("block_shape must contain nonnegative Python integers") + arrays = {} + for name, value in inputs.items(): + array = np.asarray(value) + dtype = self.input_dtypes[name] + if array.dtype.newbyteorder("=") != dtype: + raise PortableArtifactError( + f"Input {name!r} must have dtype {dtype}, not {array.dtype}", status="binding_error" + ) + if block_shape is None: + block_shape = array.shape + if array.shape != block_shape: + raise PortableArtifactError( + "Input shape disagrees with block extent", status="binding_error" + ) + arrays[name] = np.require(array, dtype=dtype, requirements=["C", "A"]) + if block_shape is None: + raise ValueError("Constant-only kernels require an explicit block_shape") + if fp_errors not in {"ignore", "raise"}: + raise ValueError("fp_errors must be 'ignore' or 'raise'") + return self._handle.evaluate_block( + arrays, + block_shape, + logical_shape=logical_shape, + block_origin=block_origin, + valid_mask=valid_mask, + return_status=return_status, + fp_raise=15 if fp_errors == "raise" else 0, + ) + + def evaluate_array( + self, + inputs, + *, + shape=None, + reduction=None, + axis=None, + keepdims=False, + dtype=None, + initial=None, + where=None, + tile_items=1024, + return_report=False, + ): + """Menudet 1.0 logical broadcasting/axis reductions with bounded iterator scratch. + + Supports C/F, negative-stride and nonnative-endian numeric arrays. Results + own C-order storage; no mutable-view or in-place guarantees. Grouping is + serial logical C order, independent of tile size/storage chunks. This API + is separate from explicit block-scalar evaluation. + """ + inputs = _mapping(inputs, "inputs") + if set(inputs) != set(self.input_dtypes): + raise PortableArtifactError("Missing or extra runtime inputs", status="binding_error") + arrays = {name: np.asarray(value) for name, value in inputs.items()} + for name, array in arrays.items(): + if array.dtype.newbyteorder("=") != self.input_dtypes[name]: + raise PortableArtifactError(f"Input {name!r} has incorrect dtype", status="binding_error") + if shape is None: + if not arrays: + raise ValueError("Constant-only kernels require shape") + shape = np.broadcast_shapes(*(a.shape for a in arrays.values())) + shape = (shape,) if isinstance(shape, int) else tuple(shape) + if any(type(n) is not int or n < 0 for n in shape): + raise ValueError("shape must contain nonnegative Python integers") + if reduction not in {None, "sum", "prod", "min", "max", "any", "all"}: + raise ValueError("Unsupported logical reduction") + if reduction is None and ( + axis is not None or dtype is not None or initial is not None or where is not None + ): + raise ValueError("Reduction options require a reduction") + axes = None if axis is None else (axis,) if isinstance(axis, int) else tuple(axis) + if axes is not None and any(type(a) is not int for a in axes): + raise TypeError("axis entries must be integers") + if type(tile_items) is not int or tile_items <= 0: + raise ValueError("tile_items must be a positive integer") + values, report = self._handle.evaluate_array( + arrays, shape, reduction, axes, keepdims, dtype, initial, where, tile_items + ) + return (values, report) if return_report else values + + def evaluate_sources(self, inputs, *, shape=None, selection=None, tile_items=65536, return_report=False): + """Evaluate eligible lane-local kernels using bounded storage readers. + + NumPy buffers remain resident; compressed inputs are read one native tile + at a time. Basic selections do not read discarded lanes. Block reductions, + locals/loops, context-dependent kernels and final conversions reject before + reads. Unsupported runtimes reject; numerical/storage failures never replay. + Report scratch excludes output, Python tile metadata and codec internals. + """ + from .storage_readers import evaluate_storage_sources + + values, report = evaluate_storage_sources(self, inputs, shape, selection, tile_items) + return (values, report) if return_report else values + + def lazy(self, inputs, *, shape=None, partitions=None): + """Bind native inputs to an immutable logical block grid, not a storage grid.""" + from .portable_lazy import PortableLazyArray + + if self.schema_version != "1.0": + raise NotImplementedError("Logical portable partitions require the descriptor profile") + return PortableLazyArray(self, inputs, shape=shape, partitions=partitions) diff --git a/src/blosc2/portable_lazy.py b/src/blosc2/portable_lazy.py new file mode 100644 index 000000000..d2162fd3b --- /dev/null +++ b/src/blosc2/portable_lazy.py @@ -0,0 +1,354 @@ +"""Native portable kernels over immutable logical partitions, independent of storage tiles.""" + +from itertools import product +from math import prod + +import numpy as np + +import blosc2 +from blosc2.lazyexpr import LazyArray + + +def portable_from_lazyudf(obj): + """Preflight a newly authored DSL recipe without executing it or touching storage.""" + from blosc2.dsl_kernel import DSLKernel + from blosc2.portable_kernel import PortableArtifactError, PortableKernel + + if not isinstance(obj.func, DSLKernel): + raise TypeError("Python LazyUDF cannot be persisted; use a compliant DSLKernel or PortableKernel") + schunk = getattr(obj, "schunk", None) + if getattr(obj, "_legacy_source_recipe", False) or ( + schunk is not None + and (schunk.meta.get("LazyArray") is not None or schunk.meta.get("b2o", {}).get("kind") == "lazyudf") + ): + raise TypeError("Persisting legacy source-backed LazyUDF is unsupported; author a new DSLKernel") + inputs, constants = {}, {} + for name, value in obj.inputs_dict.items(): + if np.isscalar(value): + constants[name] = value + else: + inputs[name] = value + shape = tuple(int(n) for n in obj.shape) + partitions = tuple(int(n) for n in obj.blocks) + chunks = tuple(int(n) for n in obj.chunks) + if any(c % b for c, b in zip(chunks, partitions, strict=True)): + raise ValueError( + "LazyUDF chunk boundaries split its logical block grid; use PortableKernel.lazy " + "with explicit partitions" + ) + try: + artifact = obj.func.export( + {name: value.dtype for name, value in inputs.items()}, + obj.dtype, + version="1.0", + constants=constants, + ndim=len(shape), + cardinality="elementwise", + ) + except PortableArtifactError as error: + if "return cardinality" in str(error): + raise ValueError( + "LazyUDF declares elementwise shape but the kernel returns a block scalar; " + "use DSLKernel.export(cardinality='block_scalar', version='1.0') and " + "PortableKernel.lazy with explicit partitions" + ) from error + raise + portable = PortableLazyArray( + PortableKernel.from_json(artifact, jit=False), inputs, shape=shape, partitions=partitions + ) + portable._set_user_vlmeta(obj._get_user_vlmeta(), sync=False) + return portable + + +class PortableLazyArray(LazyArray): + def __init__(self, kernel, inputs, *, shape=None, partitions=None): + self.kernel = kernel + self.inputs = dict(inputs) + input_dtypes = kernel.input_dtypes + if self.inputs.keys() != input_dtypes.keys(): + raise ValueError("Portable input names disagree with native signature") + if shape is None: + if not self.inputs: + raise ValueError("Constant-only portable arrays require shape") + shape = np.broadcast_shapes(*(value.shape for value in self.inputs.values())) + self._domain = tuple(shape) + if any(type(n) is not int or not 0 <= n <= np.iinfo(np.int64).max for n in self._domain): + raise ValueError("Logical shape must contain nonnegative integers") + if kernel.context_ndim and kernel.context_ndim != len(self._domain): + raise ValueError("Artifact context rank disagrees with logical domain") + for name, value in self.inputs.items(): + if ( + value.shape != self._domain + and np.broadcast_shapes(value.shape, self._domain) != self._domain + ) or np.dtype(value.dtype).newbyteorder("=") != input_dtypes[name]: + raise ValueError( + "Portable operands must broadcast to the logical domain and match native dtype" + ) + self._partitions = tuple(partitions if partitions is not None else (max(n, 1) for n in self._domain)) + if len(self._partitions) != len(self._domain) or any( + type(n) is not int or n <= 0 for n in self._partitions + ): + raise ValueError("Logical partitions must have matching rank and positive extents") + if prod(self._partitions) > 2147483647: + raise ValueError("Logical partition exceeds the native lane limit") + self._grid = tuple((n + p - 1) // p for n, p in zip(self._domain, self._partitions, strict=True)) + self._shape = self._grid if kernel.result_cardinality == "block_scalar" else self._domain + + @property + def shape(self): + return self._shape + + @property + def dtype(self): + return self.kernel.output_dtype + + @property + def nbytes(self): + return prod(self.shape) * self.dtype.itemsize + + @property + def partitions(self): + return self._partitions + + @property + def chunks(self): + return tuple(max(n, 1) for n in self.shape) + + @property + def blocks(self): + return self.chunks + + def _values(self, selection=None): # noqa: C901 -- bounded readers plus original partition/context paths + if selection is None: + selection = tuple(slice(None) for _ in self.shape) + elif not isinstance(selection, tuple): + selection = (selection,) + if any( + part is None or isinstance(part, bool) or not isinstance(part, (slice, int, type(Ellipsis))) + for part in selection + ): + return self._values()[selection] + if sum(part is Ellipsis for part in selection) > 1: + raise IndexError("Only one ellipsis is allowed") + if Ellipsis in selection: + position = selection.index(Ellipsis) + selection = ( + selection[:position] + + (slice(None),) * (len(self.shape) - len(selection) + 1) + + selection[position + 1 :] + ) + selection += (slice(None),) * (len(self.shape) - len(selection)) + if len(selection) != len(self.shape): + raise IndexError("Too many indices") + plan = getattr(self.kernel, "_resident_plan", None) + if ( + plan is not None + and all(part == slice(None) for part in selection) + and all(value.shape == self._domain for value in self.inputs.values()) + ): + from .native_graph import execute_resident, prepare_resident + + prepared = prepare_resident( + self.kernel._resident_expression, + self.inputs, + jit=self.kernel.has_jit, + cached=getattr(self, "_resident_native", None), + plan=plan, + ) + if prepared is not None: + self._resident_native = prepared + values, report = execute_resident(prepared, self.inputs) + self._source_execution_report = { + **report, + "route": "parallel-resident" if report["tasks"] > 1 else "native-resident", + "threads": report["tasks"], + "input_buffer_bytes": 0, + "output_copy_bytes": 0, + } + return values + from .storage_readers import evaluate_storage_if_eligible + + # Complex has no native storage shortcut yet. Use the general block + # path, which is also the portable-schedule fallback on wasm32. + complex_domain = self.kernel.output_dtype.kind == "c" or any( + dtype.kind == "c" for dtype in self.kernel.input_dtypes.values() + ) + streamed = None if complex_domain else evaluate_storage_if_eligible(self, selection) + if streamed is not None: + values, self._source_execution_report = streamed + return values + from .resident_execution import ( + evaluate_resident_if_eligible, + evaluate_resident_selection_if_eligible, + ) + + selected = None if complex_domain else evaluate_resident_selection_if_eligible(self, selection) + if selected is not None: + values, self._source_execution_report = selected + return values + resident = None if complex_domain else evaluate_resident_if_eligible(self, selection) + if resident is not None: + values, self._source_execution_report = resident + return values + if ( + self.kernel.result_cardinality == "elementwise" + and all(groups == 1 for groups in self._grid) + and all( + isinstance(part, slice) and part.indices(size) == (0, size, 1) + for part, size in zip(selection, self.shape, strict=True) + ) + ): + # One complete original group needs neither coordinate index arrays + # nor advanced-index copies. Keep evaluate_block (not evaluate_array): + # block reductions and native coordinates must see that entire group. + domain = self._domain + dtypes = self.kernel.input_dtypes + operands = {} + exact = not self.kernel.context_ndim + for name, value in self.inputs.items(): + array = np.asarray(value[()]) + if type(array) is np.ndarray and array.shape == domain and array.dtype == dtypes.get(name): + operands[name] = array + else: + exact = False + operands[name] = np.broadcast_to(array, domain) + if exact and all( + value.dtype.isnative and value.flags.c_contiguous and value.flags.aligned + for value in operands.values() + ): + return self.kernel.evaluate_block(operands, block_shape=domain, _validated=True) + context = ( + {"logical_shape": self._domain, "block_origin": (0,) * len(self._domain)} + if self.kernel.context_ndim + else {} + ) + return self.kernel.evaluate_block(operands, block_shape=self._domain, **context) + selected, squeeze = [], [] + for axis, (part, size) in enumerate(zip(selection, self.shape, strict=True)): + if isinstance(part, int): + index = part + size if part < 0 else part + if not 0 <= index < size: + raise IndexError("Portable output index out of range") + selected.append(np.array([index], dtype=np.intp)) + squeeze.append(axis) + else: + selected.append(np.arange(*part.indices(size), dtype=np.intp)) + result = np.empty(tuple(len(indices) for indices in selected), dtype=self.dtype) + scalar = self.kernel.result_cardinality == "block_scalar" + groups = [ + np.unique(indices if scalar else indices // p) + for indices, p in zip(selected, self._partitions, strict=True) + ] + # Always read complete original groups. Output slicing/rechunking never + # changes reduction membership or the domain used by native coordinates. + for index in product(*groups): + index = tuple(int(i) for i in index) + origin = tuple(i * p for i, p in zip(index, self._partitions, strict=True)) + extent = tuple( + min(p, n - o) for p, n, o in zip(self._partitions, self._domain, origin, strict=True) + ) + item = tuple(slice(o, o + n) for o, n in zip(origin, extent, strict=True)) + operands = {} + for name, value in self.inputs.items(): + rank = len(value.shape) + source_item = ( + tuple( + slice(0, 1) if size == 1 else part + for size, part in zip(value.shape, item[len(item) - rank :], strict=True) + ) + if rank + else () + ) + operands[name] = np.broadcast_to(np.asarray(value[source_item]), extent) + context = ( + {"logical_shape": self._domain, "block_origin": origin} if self.kernel.context_ndim else {} + ) + block = self.kernel.evaluate_block(operands, block_shape=extent, **context) + positions = [ + np.flatnonzero(indices == i) + if scalar + else np.flatnonzero((indices >= o) & (indices < o + n)) + for indices, i, o, n in zip(selected, index, origin, extent, strict=True) + ] + local = [indices[pos] - o for indices, pos, o in zip(selected, positions, origin, strict=True)] + if not self.shape: + result[...] = block + else: + result[np.ix_(*positions)] = block if scalar else block[np.ix_(*local)] + return np.squeeze(result, axis=tuple(squeeze)) if squeeze else result + + def __getitem__(self, item): + return self._values(item) + + def compute(self, item=None, **kwargs): + """Materialize into Blosc2 storage, honoring output storage options. + + Eligible lane-local float or proven modular integer kernels over matching + compressed 1-D inputs write directly through a native prefilter. Omitted chunks/blocks + retain the input grid on this path. Partial selections and different + output grids keep the general partition-preserving implementation. + """ + if item is not None: + return blosc2.asarray(self._values(item), **kwargs) + from .storage_readers import compute_storage_if_eligible + + streamed = compute_storage_if_eligible(self, kwargs) + if streamed is not None: + output, self._source_execution_report = streamed + return output + output = blosc2.empty(self.shape, dtype=self.dtype, **kwargs) + if not self.shape: + output[()] = self._values() + return output + # Output storage tiles may intersect several immutable source groups. + # Re-evaluation at a tile boundary is permitted, repartitioning is not. + for origin in product(*(range(0, n, c) for n, c in zip(self.shape, output.chunks, strict=True))): + item = tuple( + slice(o, min(o + c, n)) for o, c, n in zip(origin, output.chunks, self.shape, strict=True) + ) + output[item] = self._values(item) + return output + + def rechunk(self, *, chunks=None, blocks=None, **kwargs): + """Materialize into a different storage grid, retaining logical groups.""" + return self.compute(chunks=chunks, blocks=blocks, **kwargs) + + def sort(self, order=None): + raise NotImplementedError("Portable sorting is not part of the kernel contract") + + def argsort(self, order=None): + raise NotImplementedError("Portable sorting is not part of the kernel contract") + + def save(self, urlpath=None, **kwargs): + from blosc2.b2objects import ( + encode_b2object_payload, + make_b2object_carrier, + write_b2object_payload, + write_b2object_user_vlmeta, + ) + + if urlpath is None: + raise ValueError("A portable carrier requires urlpath") + payload = encode_b2object_payload(self) # Preflight every reference before opening destination. + from blosc2.msgpack_utils import msgpack_packb + + msgpack_packb(payload) + msgpack_packb(self._get_user_vlmeta()) + carrier = make_b2object_carrier("portable", self.shape, self.dtype, urlpath=urlpath, **kwargs) + write_b2object_payload(carrier, payload) + write_b2object_user_vlmeta(carrier, self._get_user_vlmeta()) + self.array, self.schunk = carrier, carrier.schunk + + def to_cframe(self, **kwargs): + from blosc2.b2objects import ( + encode_b2object_payload, + make_b2object_carrier, + write_b2object_payload, + write_b2object_user_vlmeta, + ) + + payload = encode_b2object_payload(self) + carrier = make_b2object_carrier("portable", self.shape, self.dtype, **kwargs) + write_b2object_payload(carrier, payload) + write_b2object_user_vlmeta(carrier, self._get_user_vlmeta()) + return carrier.to_cframe() diff --git a/src/blosc2/prepared_evaluate.py b/src/blosc2/prepared_evaluate.py new file mode 100644 index 000000000..9aab2c414 --- /dev/null +++ b/src/blosc2/prepared_evaluate.py @@ -0,0 +1,152 @@ +"""Reusable, operand-free expression evaluators with explicit rebinding.""" + +import sys +import threading +import weakref +from contextlib import contextmanager +from dataclasses import dataclass +from functools import wraps + +from .expression_graph import evaluation_mode, expression_evaluation, parse_expression + +_evaluation_state = threading.local() + + +@contextmanager +def independent_evaluation(): + """Keep explicit prepared calls and nested evaluations out of implicit state.""" + previous = getattr(_evaluation_state, "depth", 0) + _evaluation_state.depth = previous + 1 + try: + yield + finally: + _evaluation_state.depth = previous + + +def remember_evaluation(function): + """Record successful public calls without retaining operands or stack frames.""" + + @wraps(function) + def wrapped(ex, local_dict=None, global_dict=None, out=None, **options): + outermost = getattr(_evaluation_state, "depth", 0) == 0 + mode = evaluation_mode() + if local_dict is None or global_dict is None: + frame = sys._getframe(1) + try: + if local_dict is None: + local_dict = frame.f_locals + if global_dict is None: + global_dict = frame.f_globals + finally: + del frame + with independent_evaluation(): + result = function(ex, local_dict=local_dict, global_dict=global_dict, out=out, **options) + if outermost: + # An unsupported weak-reference destination must not turn a successful + # evaluation into a failure or introduce strong array retention. + try: + destination = None if out is None else weakref.ref(out) + except TypeError: + destination = None + _evaluation_state.last = (ex, dict(options), mode, destination) + return result + + return wrapped + + +def re_evaluate(local_dict=None, global_dict=None, _frame_depth=2): + """Repeat this thread's last successful public :func:`blosc2.evaluate` call. + + Operands are looked up anew in the supplied dictionaries or calling scope. + The previous explicit output is reused if it is still alive; otherwise a + fresh result is allocated. Output references are weak, and operands are never + retained. Failed calls and explicit prepared-evaluator calls do not replace + the saved expression. Unlike NumExpr's unchecked shortcut, shape/dtype/output + validation is retained when operands change. + + ``_frame_depth`` is an internal compatibility argument: the default resolves + the direct caller. A wrapper can increase it to resolve its own caller. + """ + from .lazyexpr import evaluate + + last = getattr(_evaluation_state, "last", None) + if last is None: + raise RuntimeError("No previous successful evaluate() in this thread; call evaluate() first") + if type(_frame_depth) is not int or _frame_depth < 2: + raise ValueError("_frame_depth must be an integer >= 2") + if local_dict is None or global_dict is None: + frame = sys._getframe(_frame_depth - 1) + try: + if local_dict is None: + local_dict = frame.f_locals + if global_dict is None: + global_dict = frame.f_globals + finally: + del frame + expression, options, mode, destination = last + if evaluation_mode() == "safe": + mode = "safe" + with independent_evaluation(), expression_evaluation(mode): + return evaluate( + expression, + local_dict=local_dict, + global_dict=global_dict, + out=None if destination is None else destination(), + **options, + ) + + +@dataclass(frozen=True, slots=True) +class PreparedEvaluator: + """An immutable expression recipe; execution never retains input/output arrays. + + Construct with :func:`blosc2.prepare_evaluate`. Dtypes and shapes are inferred + on each binding; the existing bounded preparation caches reuse compatible + signatures. Compilation is lazy on first execution, not at construction. + """ + + expression: str + input_names: tuple[str, ...] + options: tuple + evaluation: str + + def __call__(self, local_dict, *, out=None, **options): + """Evaluate with explicit operands and optional per-call option overrides.""" + from .lazyexpr import evaluate + + missing = set(self.input_names) - local_dict.keys() + if missing: + raise NameError(f"Missing expression operands: {', '.join(sorted(missing))}") + bindings = {name: local_dict[name] for name in self.input_names} + policy = dict(self.options) | options + # A recipe created in full mode cannot weaken a surrounding safe scope. + mode = "safe" if evaluation_mode() == "safe" else self.evaluation + with independent_evaluation(), expression_evaluation(mode): + return evaluate(self.expression, local_dict=bindings, global_dict={}, out=out, **policy) + + def evaluate(self, local_dict, *, out=None, **options): + """Named equivalent of calling the evaluator.""" + return self(local_dict, out=out, **options) + + +def prepare_evaluate(expression, **options): + """Validate an expression once and return an explicit reusable evaluator. + + No caller variables are captured. Supply a mapping on every invocation: + + >>> import blosc2 + >>> import numpy as np + >>> evaluator = blosc2.prepare_evaluate("x + 1") + >>> evaluator({"x": np.arange(3)}) + array([1, 2, 3]) + + The approved expression grammar is used in both safe and full modes. Options + match :func:`blosc2.evaluate`; per-call overrides do not mutate the recipe. + """ + from .lazyexpr import validate_evaluate_options + + validate_evaluate_options(options) + graph = parse_expression(expression) + return PreparedEvaluator( + expression, tuple(sorted(graph.names)), tuple(sorted(options.items())), evaluation_mode() + ) diff --git a/src/blosc2/proxy.py b/src/blosc2/proxy.py index db3efb64c..c509ca8e9 100644 --- a/src/blosc2/proxy.py +++ b/src/blosc2/proxy.py @@ -232,6 +232,9 @@ def __init__( """ self.src = src + # Cached chunks belong to this source, even if a caller later rebinds + # the public src attribute. Safe expression admission checks provenance. + self._cache_source = src self.urlpath = urlpath self._cache_status = None if kwargs is None: @@ -2160,6 +2163,8 @@ def dsl_wrapper(*args, **func_kwargs): } storage_kwargs = {k: v for k, v in decorator_kwargs.items() if k not in _JIT_EXECUTION_TUNING_KWARGS} lexpr = blosc2.lazyudf(kernel, values, dtype=None, shape=shape, **exec_kwargs) + # Native control-flow wrappers must not silently select full/legacy DSL. + lexpr._require_menudet = not blosc2.IS_WASM if out is not None: if isinstance(out, blosc2.NDArray): diff --git a/src/blosc2/remote_array.py b/src/blosc2/remote_array.py index 98fca9507..630dbd905 100644 --- a/src/blosc2/remote_array.py +++ b/src/blosc2/remote_array.py @@ -759,6 +759,7 @@ def __init__( _runtime_cache_path = self._carrier_path(cache_dir, None) + ".cache" self._runtime_urlpath = self._runtime_source(urlpath) self._expected_geometry = self._geometry(self.src) + self._expression_source = self.src self._expected_cparams = self.src.cparams self._refresh_lock = threading.Lock() self._operation_lock = threading.RLock() diff --git a/src/blosc2/remote_parquet.py b/src/blosc2/remote_parquet.py index 718d0b692..d17c28b3d 100644 --- a/src/blosc2/remote_parquet.py +++ b/src/blosc2/remote_parquet.py @@ -716,6 +716,7 @@ class _ParquetColumn: def __init__(self, storage, name, mask=False): self.storage = storage + self._source_storage = storage self.name = name self.mask = mask self.shape = (storage.length,) diff --git a/src/blosc2/remote_store_cache.py b/src/blosc2/remote_store_cache.py index 648e18e84..2dfd9e040 100644 --- a/src/blosc2/remote_store_cache.py +++ b/src/blosc2/remote_store_cache.py @@ -1,10 +1,12 @@ """Exclusive ownership and atomic discovery manifests for disposable store caches.""" +import errno import json import os import shutil import tempfile import threading +import time import uuid from contextlib import contextmanager from pathlib import Path @@ -33,8 +35,21 @@ def lock_cache_file(file, *, blocking=False): # Windows permits locking a byte beyond EOF. Do not initialize the byte: # another owner may already have locked it, making even a write fail # before LK_LOCK gets a chance to wait for ownership. - file.seek(0) - msvcrt.locking(file.fileno(), msvcrt.LK_LOCK if blocking else msvcrt.LK_NBLCK, 1) + while True: + file.seek(0) + try: + msvcrt.locking(file.fileno(), msvcrt.LK_NBLCK, 1) + break + except OSError as exc: + if not blocking or ( + exc.errno not in (errno.EACCES, errno.EAGAIN, errno.EDEADLK) + and getattr(exc, "winerror", None) != 33 + ): + raise + # LK_LOCK stops after ten one-second retries. Shared cache + # operations need the same unbounded wait as POSIX LOCK_EX; + # slow discovery/publication must not look like lifetime ownership. + time.sleep(0.05) else: import fcntl diff --git a/src/blosc2/resident_execution.py b/src/blosc2/resident_execution.py new file mode 100644 index 000000000..0cd679a00 --- /dev/null +++ b/src/blosc2/resident_execution.py @@ -0,0 +1,260 @@ +"""Parallel full reads of conservatively proven lane-local resident recipes.""" + +import ast +from concurrent.futures import ThreadPoolExecutor, wait +from functools import lru_cache +from math import prod + +import numpy as np + +from .storage_readers import storage_reader_eligible + +MINIMUM_WORKER_ITEMS = 128 * 1024 +MAXIMUM_WORKERS = 32 + + +@lru_cache(maxsize=1) +def resident_pool(): + # Reuse threads across warm reads. The executor joins them at interpreter exit. + return ThreadPoolExecutor(max_workers=MAXIMUM_WORKERS, thread_name_prefix="menudet-resident") + + +def evaluate_resident_if_eligible(lazy, selection, out=None): + import blosc2 + + count = prod(lazy._domain) + workers = min(blosc2.nthreads, MAXIMUM_WORKERS, count // MINIMUM_WORKER_ITEMS) + if workers < 2 or blosc2.IS_WASM or not lazy.inputs: + return None + if not getattr(blosc2.blosc2_ext, "portable_resident_available", lambda: False)(): + return None + floating = all(dtype.kind == "f" for dtype in lazy.kernel.input_dtypes.values()) + if floating: + if not storage_reader_eligible(lazy.kernel) or not resident_scalar_operations_safe(lazy.kernel): + return None + elif not resident_integer_operations_safe(lazy.kernel): + return None + if not all( + isinstance(part, slice) and part.indices(size) == (0, size, 1) + for part, size in zip(selection, lazy._domain, strict=True) + ): + return None + if any( + type(value) is not np.ndarray + or value.shape != lazy._domain + or not value.flags.c_contiguous + or not value.flags.aligned + or not value.dtype.isnative + or value.dtype != lazy.kernel.input_dtypes[name] + for name, value in lazy.inputs.items() + ): + return None + return evaluate_resident(lazy.kernel, lazy.inputs, lazy._domain, workers, out=out) + + +def resident_integer_operations_safe(kernel): + """Prove a same-dtype modular integer recipe cannot fail in any lane. + + Shared by resident workers and bounded storage/prefilter admission. Checked + weak subtrees, captures, casts and mixed dtypes retain their original + invocation/error domain. + """ + if hasattr(kernel, "native_partitionable"): + return kernel.native_partitionable + return _resident_integer_operations_safe_legacy(kernel) + + +def _resident_integer_operations_safe_legacy(kernel): + """Compatibility proof for portable kernels without native graph metadata.""" + if not kernel.input_dtypes: + return False + dtype = next(iter(kernel.input_dtypes.values())) + if ( + dtype.kind not in "iu" + or kernel.inferred_dtype != kernel.output_dtype + or kernel.result_cardinality != "elementwise" + or kernel.context_ndim + or any(value != dtype for value in kernel.input_dtypes.values()) + ): + return False + try: + function = ast.parse(kernel.source).body[0] + except (SyntaxError, IndexError): + return False + if ( + not isinstance(function, ast.FunctionDef) + or len(function.body) != 1 + or not isinstance(function.body[0], ast.Return) + ): + return False + bounds = np.iinfo(dtype) + + def prove(node): + # Return (safe, contains_runtime_array). Only literal leaves may be weak; + # every arithmetic subtree must contain an array before it can wrap. + if isinstance(node, ast.Name): + return node.id in kernel.input_dtypes, node.id in kernel.input_dtypes + literal = node + sign = 1 + if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)): + literal = node.operand + sign = -1 if isinstance(node.op, ast.USub) else 1 + if isinstance(literal, ast.Constant) and type(literal.value) is int: + return bounds.min <= sign * literal.value <= bounds.max, False + if isinstance(node, ast.BinOp) and isinstance( + node.op, (ast.Add, ast.Sub, ast.Mult, ast.BitAnd, ast.BitOr, ast.BitXor) + ): + left, left_array = prove(node.left) + right, right_array = prove(node.right) + runtime = left_array or right_array + return left and right and runtime, runtime + if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub, ast.Invert)): + safe, runtime = prove(node.operand) + return safe and runtime, runtime + return False, False + + expression = function.body[0].value + if isinstance(expression, ast.Compare): + if ( + kernel.output_dtype != np.dtype("bool") + or len(expression.ops) != 1 + or not isinstance(expression.ops[0], (ast.Eq, ast.NotEq, ast.Lt, ast.LtE, ast.Gt, ast.GtE)) + ): + return False + left, left_array = prove(expression.left) + right, right_array = prove(expression.comparators[0]) + return left and right and (left_array or right_array) + if kernel.output_dtype != dtype: + return False + safe, runtime = prove(expression) + return safe and runtime + + +def evaluate_resident_selection_if_eligible(lazy, selection): + """Retile only a proven lane-local NumPy recipe, never its logical contract. + + Partial reads and compressed-output tiles otherwise evaluate complete original + groups and build large coordinate arrays. For these pure recipes membership + and coordinates have no effect, so normalize only the selected input views. + Explicit block evaluation, reductions, captures and checked recipes are unchanged. + """ + import blosc2 + + if ( + not lazy._domain + or not lazy.inputs + or any(type(value) is not np.ndarray for value in lazy.inputs.values()) + ): + return None + if all( + isinstance(part, slice) and part.indices(size) == (0, size, 1) + for part, size in zip(selection, lazy._domain, strict=True) + ): + return None + floating = all(dtype.kind == "f" for dtype in lazy.kernel.input_dtypes.values()) + if floating: + if not storage_reader_eligible(lazy.kernel) or not resident_scalar_operations_safe(lazy.kernel): + return None + elif not resident_integer_operations_safe(lazy.kernel): + return None + item, squeeze = [], [] + for axis, (part, size) in enumerate(zip(selection, lazy._domain, strict=True)): + if isinstance(part, int): + index = part + size if part < 0 else part + if not 0 <= index < size: + raise IndexError("Portable output index out of range") + item.append(slice(index, index + 1)) + squeeze.append(axis) + else: + item.append(part) + operands, temporary_bytes = {}, 0 + for name, value in lazy.inputs.items(): + dtype = lazy.kernel.input_dtypes[name] + if value.dtype.newbyteorder("=") != dtype: + return None + view = np.broadcast_to(value, lazy._domain)[tuple(item)] + if not view.flags.c_contiguous or not view.flags.aligned or not view.dtype.isnative: + temporary_bytes += view.nbytes + operands[name] = np.require(view, dtype=dtype, requirements=["C", "A"]) + shape = next(iter(operands.values())).shape + count = prod(shape) + workers = min(blosc2.nthreads, MAXIMUM_WORKERS, count // MINIMUM_WORKER_ITEMS) + if ( + workers >= 2 + and not blosc2.IS_WASM + and getattr(blosc2.blosc2_ext, "portable_resident_available", lambda: False)() + ): + values, report = evaluate_resident(lazy.kernel, operands, shape, workers) + report["route"] = "parallel-resident-selection" + else: + values, status = lazy.kernel.evaluate_block(operands, block_shape=shape, return_status=True) + report = { + "route": "resident-selection", + "threads": 1, + "fp_flags": status["flags"], + "fp_supported": status["supported"], + } + report["input_buffer_bytes"] = temporary_bytes + return np.squeeze(values, axis=tuple(squeeze)) if squeeze else values, report + + +def resident_scalar_operations_safe(kernel): + if hasattr(kernel, "native_partitionable"): + return kernel.native_partitionable + # The common gate excludes reductions/context/captures/final conversions. + # Also exclude constant-only arithmetic: its weak result can require a + # checked conversion even when each literal individually fits the dtype. + limit = float(min(np.finfo(dtype).max for dtype in kernel.input_dtypes.values())) + for node in ast.walk(ast.parse(kernel.source)): + if isinstance(node, ast.Constant) and isinstance(node.value, int) and abs(node.value) > limit: + return False + if isinstance(node, (ast.BinOp, ast.UnaryOp, ast.Call, ast.Compare)) and not any( + isinstance(child, ast.Name) and child.id in kernel.input_dtypes for child in ast.walk(node) + ): + return False + return True + + +def evaluate_resident(kernel, inputs, shape, workers, out=None): + """Keep output alive until every worker joins; never replay failures.""" + count = prod(shape) + output = np.empty(shape, dtype=kernel.output_dtype) if out is None else out + if type(output) is not np.ndarray or output.shape != shape or output.dtype != kernel.output_dtype: + raise ValueError("Resident output shape/dtype disagree with the kernel") + if not output.flags.c_contiguous or not output.flags.aligned or not output.flags.writeable: + raise ValueError("Resident output must be writable, aligned and C-contiguous") + if any(np.shares_memory(output, value) for value in inputs.values()): + raise ValueError("Resident output must not overlap an input") + flat_output = output.reshape(-1) + flat_inputs = {name: value.reshape(-1) for name, value in inputs.items()} + futures = [] + try: + for worker in range(workers): + start, stop = count * worker // workers, count * (worker + 1) // workers + operands = {name: value[start:stop] for name, value in flat_inputs.items()} + futures.append( + resident_pool().submit( + kernel._handle.evaluate_block, + operands, + (stop - start,), + return_status=True, + _output=flat_output[start:stop], + ) + ) + finally: + # Even submission failures wait for in-flight writes before unwinding. + wait(futures) + flags, supported = 0, True + for future in futures: + # Logical region order determines which failure is reported. + _, status = future.result() + flags |= status["flags"] + supported &= status["supported"] + return output, { + "route": "parallel-resident", + "threads": workers, + "fp_flags": flags, + "fp_supported": supported, + "input_buffer_bytes": 0, + "output_copy_bytes": 0, + } diff --git a/src/blosc2/schunk.py b/src/blosc2/schunk.py index aa058e044..d53232eba 100644 --- a/src/blosc2/schunk.py +++ b/src/blosc2/schunk.py @@ -1976,7 +1976,9 @@ def process_opened_object(res, *, deserialize=DeserializeMode.SAFE): return proxy if "b2o" in meta: - if deserialize is DeserializeMode.SAFE: + if deserialize is DeserializeMode.SAFE and ( + not isinstance(meta["b2o"], dict) or meta["b2o"].get("kind") not in {"portable", "lazyexpr"} + ): marker = meta["b2o"] kind = marker.get("kind", "b2o") if isinstance(marker, dict) else "b2o" raise UnsafeDeserializationError(str(kind)) diff --git a/src/blosc2/storage_readers.py b/src/blosc2/storage_readers.py new file mode 100644 index 000000000..d7ef3d182 --- /dev/null +++ b/src/blosc2/storage_readers.py @@ -0,0 +1,545 @@ +"""Bounded adapters for the native portable array storage-reader ABI.""" + +import ast +from dataclasses import replace + +import numpy as np + +DENSE_MATERIALIZATION_BUDGET = 32 * 1024**2 + + +def storage_reader_eligible(kernel): + """Conservative metadata-only gate; block/context dependence never retile.""" + from . import blosc2_ext + + if not getattr(blosc2_ext, "native_array_sources_available", lambda: False)(): + return False + if kernel.result_cardinality != "elementwise" or kernel.context_ndim: + return False + if kernel.inferred_dtype != kernel.output_dtype or kernel.output_dtype.kind not in "biuf": + return False + if any(dtype.kind not in "biuf" for dtype in kernel.input_dtypes.values()): + return False + if hasattr(kernel, "native_partitionable"): + return kernel.native_partitionable + if any(dtype.kind in "iu" for dtype in kernel.input_dtypes.values()): + from .resident_execution import resident_integer_operations_safe + + # Same-width modular integer recipes (including in-range literal leaves) + # cannot fail or observe group membership. Reuse the resident proof rather + # than replay whole logical groups for every compressed output tile. + return _source_is_lane_local(kernel) or resident_integer_operations_safe(kernel) + return _source_is_lane_local(kernel) + + +def _source_is_lane_local(kernel): + try: + function = ast.parse(kernel.source).body[0] + except (SyntaxError, IndexError): + return False + if not isinstance(function, ast.FunctionDef) or len(function.body) != 1: + return False + if not isinstance(function.body[0], ast.Return): + return False + # Calls with checked conversions or block reductions cannot change their + # original invocation/error-order domain. Pure float math is lane-local. + functions = { + "abs", + "sqrt", + "cbrt", + "exp", + "exp2", + "expm1", + "log", + "log1p", + "log2", + "log10", + "sin", + "cos", + "tan", + "asin", + "acos", + "atan", + "atan2", + "arctan2", + "sinh", + "cosh", + "tanh", + "asinh", + "acosh", + "atanh", + "fmod", + "copysign", + "hypot", + "nextafter", + "ceil", + "floor", + "round", + "rint", + "trunc", + "sign", + "isnan", + "isfinite", + "isinf", + "signbit", + "minimum", + "maximum", + "where", + } + floating = all(dtype.kind == "f" for dtype in kernel.input_dtypes.values()) + float_limit = float( + min( + (np.finfo(dtype).max for dtype in kernel.input_dtypes.values() if dtype.kind == "f"), + default=np.inf, + ) + ) + for node in ast.walk(function.body[0].value): + if isinstance(node, ast.Name) and node.id not in kernel.input_dtypes and node.id not in functions: + # Captured weak scalars may require checked conversions. Keep their + # original invocation/error domain until native metadata proves safety. + return False + if ( + isinstance(node, ast.Constant) + and isinstance(node.value, float) + and not abs(node.value) <= float_limit + ): + return False + if isinstance(node, (ast.Subscript, ast.Attribute, ast.List, ast.Tuple, ast.LShift, ast.RShift)): + return False + if isinstance(node, (ast.BinOp, ast.UnaryOp)): + descendants = tuple(ast.walk(node)) + # Weak integer intermediates remain checked, even in an eventual + # float expression. Retiling must not reorder those failures. + if not any( + (isinstance(child, ast.Name) and child.id in kernel.input_dtypes) + or (isinstance(child, ast.Constant) and isinstance(child.value, float)) + for child in descendants + ): + return False + if not floating and any(isinstance(child, ast.Constant) for child in descendants): + return False + if isinstance(node, ast.Call) and ( + not floating or not isinstance(node.func, ast.Name) or node.func.id not in functions + ): + return False + if ( + isinstance(node, ast.BinOp) + and isinstance(node.op, (ast.Div, ast.FloorDiv, ast.Mod, ast.Pow)) + and not floating + ): + return False + return True + + +class StorageReader: + """Invocation-local source values; every allocation scales with one tile.""" + + def __init__(self, value, domain, selection=None): + self.value = value + self.domain = domain + self.selection = selection + self.shape = ( + value.shape + if selection is None + else tuple( + len(range(*part.indices(size))) + for part, size in zip(selection, domain, strict=True) + if isinstance(part, slice) + ) + ) + + def read(self, indices): + import blosc2 + + indices = np.asarray(indices, dtype=np.int64) + if self.selection is not None: + remaining = indices.copy() + mapped = np.zeros(indices.shape, dtype=np.int64) + stride = 1 + for axis in range(len(self.domain) - 1, -1, -1): + part = self.selection[axis] + if isinstance(part, int): + coordinate = part + else: + start, stop, step = part.indices(self.domain[axis]) + size = len(range(start, stop, step)) + coordinate = (remaining % size) * step + start + remaining //= size + source_axis = axis - len(self.domain) + len(self.value.shape) + if source_axis >= 0: + extent = self.value.shape[source_axis] + if extent != 1: + mapped += coordinate * stride + stride *= extent + indices = mapped + if type(self.value) is blosc2.NDArray: + if self.value.ndim == 0: + return np.repeat(np.asarray(self.value[()]).reshape(1), indices.size) + if self.value.ndim == 1 and indices.size and np.all(np.diff(indices) == 1): + values = np.empty(indices.size, dtype=self.value.dtype) + position, first = 0, int(indices[0]) + chunk_items = self.value.chunks[0] + while position < indices.size: + chunk, offset = divmod(first + position, chunk_items) + count = min(indices.size - position, chunk_items - offset) + self.value.get_1d_span_numpy( + values[position : position + count], chunk, offset, count, nthreads=1 + ) + position += count + return values + return self.value._take_sparse_normalized(indices) + return self.value.flat[indices] + + +class ReaderState: + def __init__(self, reader): + self.reader = reader + self.dtype = np.dtype(reader.value.dtype).newbyteorder("=") + self.error = None + self.max_items = self.read_bytes = 0 + + +def _normalize_selection(selection, domain): + if selection is not None: + if len(selection) != len(domain): + raise ValueError("Storage selection must have matching rank") + normalized = [] + for part, size in zip(selection, domain, strict=True): + if isinstance(part, int): + part = part + size if part < 0 else part + if not 0 <= part < size: + raise IndexError("Portable output index out of range") + elif not isinstance(part, slice): + raise TypeError("Storage readers support basic integer/slice selection") + normalized.append(part) + selection = tuple(normalized) + if all( + isinstance(part, slice) and part.indices(size) == (0, size, 1) + for part, size in zip(selection, domain, strict=True) + ): + selection = None + return selection + + +def evaluate_storage_if_eligible(lazy, selection): + import blosc2 + + if not any(type(value) is blosc2.NDArray for value in lazy.inputs.values()): + return None + if any(type(value) not in (np.ndarray, blosc2.NDArray) for value in lazy.inputs.values()): + return None + if not storage_reader_eligible(lazy.kernel): + return None + if _normalize_selection(selection, lazy._domain) is None and _dense_compressed_eligible(lazy): + return _evaluate_dense_compressed(lazy) + return lazy.kernel.evaluate_sources( + lazy.inputs, shape=lazy._domain, selection=selection, return_report=True + ) + + +def _compute_resident_prefilter(lazy, kwargs): + """Borrow resident operands directly inside stored-output compression workers.""" + import blosc2 + + if ( + len(lazy.shape) != 1 + or not lazy.shape[0] + or any( + value.shape != lazy.shape or not value.flags.c_contiguous or not value.flags.aligned + for value in lazy.inputs.values() + ) + ): + return None + options = dict(kwargs) + output = options.pop("out", None) + if output is None: + cparams = options.get("cparams") + if cparams is None: + cparams = blosc2.CParams() + elif isinstance(cparams, dict): + cparams = blosc2.CParams(**cparams) + chunks, blocks = blosc2.compute_chunks_blocks( + lazy.shape, + chunks=options.get("chunks"), + blocks=options.get("blocks"), + dtype=lazy.dtype, + cparams=cparams, + ) + if chunks[0] % blocks[0] or chunks[0] * lazy.dtype.itemsize > DENSE_MATERIALIZATION_BUDGET: + return None + options.update(chunks=chunks, blocks=blocks, cparams=cparams) + output = blosc2.uninit(lazy.shape, dtype=lazy.dtype, **options) + elif ( + type(output) is not blosc2.NDArray + or options + or output.shape != lazy.shape + or output.dtype != lazy.dtype + ): + return None + if not blosc2.blosc2_ext.portable_prefilter_inputs_eligible( + lazy.inputs, allow_numpy=True, output=output + ): + return None + return lazy.kernel._handle.evaluate_prefilter(lazy.inputs, out=output) + + +def compute_storage_if_eligible(lazy, kwargs): + """Write a full lane-local domain directly into matching Blosc2 output tiles.""" + import blosc2 + + extension = blosc2.blosc2_ext + if ( + not storage_reader_eligible(lazy.kernel) + or not getattr(extension, "portable_prefilter_available", lambda: False)() + ): + return None + if lazy.inputs and all(type(value) is np.ndarray for value in lazy.inputs.values()): + return _compute_resident_prefilter(lazy, kwargs) + if not _dense_compressed_eligible(lazy) or not extension.portable_prefilter_inputs_eligible(lazy.inputs): + return None + first = next(iter(lazy.inputs.values())) + options = dict(kwargs) + output = options.pop("out", None) + if output is not None: + block_bytes = sum(value.blocks[0] * value.dtype.itemsize for value in lazy.inputs.values()) + for name in ("chunks", "blocks"): + requested = options.pop(name, None) + if requested is not None and tuple(requested) != getattr(first, name): + return None + if ( + type(output) is not blosc2.NDArray + or options + or output.shape != lazy.shape + or output.dtype != lazy.dtype + or output.chunks != first.chunks + or output.blocks != first.blocks + or output.cparams.nthreads * block_bytes > DENSE_MATERIALIZATION_BUDGET + or any(output is value for value in lazy.inputs.values()) + ): + return None + return lazy.kernel._handle.evaluate_prefilter(lazy.inputs, out=output) + if any( + kwargs.get(name) is not None and tuple(kwargs[name]) != getattr(first, name) + for name in ("chunks", "blocks") + ): + return None + options.update(chunks=first.chunks, blocks=first.blocks) + # Match the existing prefilter's bounded per-worker input scratch budget. + block_bytes = sum(value.blocks[0] * value.dtype.itemsize for value in lazy.inputs.values()) + thread_limit = max(1, (32 * 1024**2) // block_bytes) + cparams = options.get("cparams") + if cparams is None: + cparams = blosc2.CParams() + elif isinstance(cparams, dict): + cparams = blosc2.CParams(**cparams) + options["cparams"] = replace(cparams, nthreads=min(cparams.nthreads, thread_limit)) + output = blosc2.uninit(lazy.shape, dtype=lazy.dtype, **options) + return lazy.kernel._handle.evaluate_prefilter(lazy.inputs, out=output) + + +def evaluate_prefilter_numpy(kernel, inputs, out=None, workers=None): + """Drive the shared prefilter over coarse ranges into a direct NumPy sink. + + Each outer worker owns a single-threaded compression context and reusable + block decoders. Only the final output and a read-only dummy driver buffer + are shared; no result chunks are stored or materialized. + """ + from concurrent.futures import wait + + import blosc2 + + from .resident_execution import resident_pool + + first = next(value for value in inputs.values() if type(value) is blosc2.NDArray) + dtype = np.dtype(kernel.output_dtype) + driver_bytes = first.chunks[0] * dtype.itemsize + compressed = [value for value in inputs.values() if type(value) is blosc2.NDArray] + workers = blosc2.nthreads if workers is None else workers + input_width = sum(value.dtype.itemsize for value in compressed) + # Amortize tiny physical blocks without changing the source layout. The + # same prefilter reads block-aligned spans; its output blocks can group + # several source blocks when no compressed result needs that block grid. + for factor in range(min(first.chunks[0] // first.blocks[0], max(1, 4096 // first.blocks[0])), 0, -1): + if first.chunks[0] // first.blocks[0] % factor: + continue + block_items = factor * first.blocks[0] + placeholder_bytes = blosc2.MAX_OVERHEAD + max( + 128, (first.chunks[0] // block_items) * (4 + 4 * dtype.itemsize) + ) + available = (DENSE_MATERIALIZATION_BUDGET - driver_bytes) // ( + block_items * input_width + placeholder_bytes + ) + if available >= workers: + break + workers = min(workers, available) + if workers < 1: + return None + output = np.empty(first.shape, dtype=dtype) if out is None else out + if type(output) is not np.ndarray or output.shape != first.shape or output.dtype != dtype: + raise ValueError("Native map output shape/dtype disagree with the expression") + if not output.flags.c_contiguous or not output.flags.aligned or not output.flags.writeable: + raise ValueError("Native map output must be writable, aligned and C-contiguous") + if any(type(value) is np.ndarray and np.shares_memory(output, value) for value in inputs.values()): + raise ValueError("Native map output must not overlap an input") + driver = np.empty(driver_bytes, dtype=np.uint8) + driver.flags.writeable = False # The callback ignores its nominal input. + if first.schunk.nchunks < max(2, (workers + 1) // 2): + # Few large chunks need block-level parallelism, not one outer worker + # per chunk. Both policies invoke the identical native prefilter. + reports = [ + kernel._handle.evaluate_prefilter( + inputs, numpy_out=output, _driver_input=driver, _nthreads=workers, _block_items=block_items + )[1] + ] + scheduling = "block-workers" + else: + workers = min(workers, first.schunk.nchunks) + futures = [] + try: + for worker in range(workers): + begin = first.schunk.nchunks * worker // workers + end = first.schunk.nchunks * (worker + 1) // workers + futures.append( + resident_pool().submit( + kernel._handle.evaluate_prefilter, + inputs, + numpy_out=output, + _chunk_range=(begin, end), + _driver_input=driver, + _block_items=block_items, + ) + ) + finally: + wait(futures) # Keep buffers and sources alive through every worker join. + reports = [future.result()[1] for future in futures] + scheduling = "chunk-ranges" + report = dict(reports[0]) + for name in ( + "evaluated_blocks", + "native_decoder_contexts", + "input_buffer_allocations", + "input_chunk_fetches", + "input_buffer_bytes", + "output_chunk_buffer_bytes", + "discarded_output_bytes", + "output_zero_fill_bytes", + ): + report[name] = sum(part[name] for part in reports) + report["fp_flags"] = 0 + for part in reports: + report["fp_flags"] |= part["fp_flags"] + report.update( + route="portable-prefilter", + scheduling=scheduling, + threads=workers, + fp_supported=all(part["fp_supported"] for part in reports), + stages=1, + jit_stages=int(kernel._handle.info()["jit"]), + interpreter_stages=int(not kernel._handle.info()["jit"]), + intermediate_bytes=0, + gathered_bytes=0, + normalization_bytes=0, + reader_bytes=sum(value.nbytes for value in compressed), + input_materialization_bytes=0, + driver_buffer_bytes=driver_bytes, + temporary_bytes=driver_bytes + report["input_buffer_bytes"] + report["output_chunk_buffer_bytes"], + tile_items=block_items, + maximum_reader_items=min(block_items, first.shape[0]), + evaluated_tiles=report["evaluated_blocks"], + output_copy_bytes=0, + ) + return output, report + + +def _evaluate_dense_compressed(lazy): + import blosc2 + + extension = blosc2.blosc2_ext + if not getattr(extension, "portable_prefilter_available", lambda: False)(): + return lazy.kernel.evaluate_sources(lazy.inputs, shape=lazy._domain, return_report=True) + if not extension.portable_prefilter_inputs_eligible(lazy.inputs): + return lazy.kernel.evaluate_sources(lazy.inputs, shape=lazy._domain, return_report=True) + values = tuple(lazy.inputs.values()) + if any(value.dtype != lazy.kernel.input_dtypes[name] for name, value in lazy.inputs.items()): + from .portable_kernel import PortableArtifactError + + raise PortableArtifactError( + "Storage input dtype disagrees with native signature", status="binding_error" + ) + decoded_bytes = sum(value.schunk.chunksize for value in values) + if values[0].schunk.nchunks == 1 and decoded_bytes <= DENSE_MATERIALIZATION_BUDGET: + operands = {} + for name, value in lazy.inputs.items(): + operands[name] = value._portable_chunk_buffer() + result, status = lazy.kernel.evaluate_block(operands, return_status=True) + return result, { + "route": "single-chunk", + "input_buffer_bytes": decoded_bytes, + "fp_flags": status["flags"], + "fp_supported": status["supported"], + } + result = evaluate_prefilter_numpy(lazy.kernel, lazy.inputs) + if result is not None: + return result + return lazy.kernel.evaluate_sources(lazy.inputs, shape=lazy._domain, return_report=True) + + +def _dense_compressed_eligible(lazy): + import blosc2 + + values = tuple(lazy.inputs.values()) + if not values or any(type(value) is not blosc2.NDArray for value in values): + return False + if any(dtype.kind not in "biuf" for dtype in lazy.kernel.input_dtypes.values()): + return False + first = values[0] + if first.ndim != 1 or not first.size or tuple(first.shape) != lazy._domain: + return False + if any( + value.shape != first.shape + or value.chunks != first.chunks + or value.blocks != first.blocks + or not value.dtype.isnative + for value in values + ): + return False + return first.chunks[0] % first.blocks[0] == 0 + + +def evaluate_storage_sources(kernel, inputs, shape=None, selection=None, tile_items=65536): + import blosc2 + + if not storage_reader_eligible(kernel): + raise NotImplementedError("Kernel/runtime is not eligible for bounded storage readers") + if set(inputs) != set(kernel.input_dtypes): + raise ValueError("Storage input names disagree with native signature") + if type(tile_items) is not int or not 0 < tile_items <= 2147483647: + raise ValueError("tile_items must be a positive native lane count") + if any(type(value) not in (np.ndarray, blosc2.NDArray) for value in inputs.values()): + raise TypeError("Storage readers require NumPy or Blosc2 arrays") + domain = np.broadcast_shapes(*(value.shape for value in inputs.values())) + if shape is not None and tuple(shape) != domain: + raise ValueError("Storage-reader shape must match the broadcast domain") + selection = _normalize_selection(selection, domain) + bound, readers = {}, {} + for name, value in inputs.items(): + if np.dtype(value.dtype).newbyteorder("=") != kernel.input_dtypes[name]: + raise TypeError(f"{name}: storage input dtype disagrees with native signature") + if type(value) is blosc2.NDArray or not value.flags.c_contiguous or not value.dtype.isnative: + reader = StorageReader(value, domain, selection) + readers[name] = ReaderState(reader) + bound[name] = value + else: + bound[name] = value if selection is None else np.broadcast_to(value, domain)[selection] + result_shape = ( + domain + if selection is None + else tuple( + len(range(*part.indices(size))) + for part, size in zip(selection, domain, strict=True) + if isinstance(part, slice) + ) + ) + values, report = kernel._handle.evaluate_sources(bound, readers, result_shape, tile_items) + report["route"] = "bounded-readers" + return values, report diff --git a/src/blosc2/tree_store.py b/src/blosc2/tree_store.py index bdc390390..dc46921ba 100644 --- a/src/blosc2/tree_store.py +++ b/src/blosc2/tree_store.py @@ -441,6 +441,9 @@ def __setitem__( """ key = self._validate_key(key) + from blosc2.b2objects import preflight_persistence + + preflight_persistence(value) if isinstance(value, blosc2.RemoteStore): self._set_remote_store_reference(key, value) return diff --git a/src/blosc2/utils.py b/src/blosc2/utils.py index 77f2d3390..e749847eb 100644 --- a/src/blosc2/utils.py +++ b/src/blosc2/utils.py @@ -9,8 +9,10 @@ import builtins import contextlib import inspect +import io import math import sys +import tokenize import warnings from itertools import product @@ -21,6 +23,58 @@ import blosc2 +# NumPy frontend spellings; native miniexpr uses the Array API/C names only. +MINIEXPR_FUNCTION_ALIASES = { + "arccos": "acos", + "arccosh": "acosh", + "arcsin": "asin", + "arcsinh": "asinh", + "arctan": "atan", + "arctan2": "atan2", + "arctanh": "atanh", +} + + +def canonicalize_miniexpr_functions(source): + """Normalize bare frontend calls without changing strings, comments or names. + + This is authoring adaptation, never artifact-import migration. Native syntax + errors are left to the compiler rather than repaired here. + """ + if not isinstance(source, str | bytes): + return source + binary = isinstance(source, bytes) + try: + text = source.decode("utf-8") if binary else source + except UnicodeDecodeError: + return source + if not any(name in text for name in MINIEXPR_FUNCTION_ALIASES): + return source + try: + tokens = list(tokenize.generate_tokens(io.StringIO(text).readline)) + except (tokenize.TokenError, IndentationError): + return source + lines = text.splitlines(keepends=True) + offsets = [0] + for line in lines: + offsets.append(offsets[-1] + len(line)) + replacements = [] + for i, token in enumerate(tokens[:-1]): + if token.type != tokenize.NAME or token.string not in MINIEXPR_FUNCTION_ALIASES: + continue + if i and tokens[i - 1].string in {".", "def"}: + continue + following = next((t for t in tokens[i + 1 :] if t.type not in {tokenize.NL, tokenize.COMMENT}), None) + if following is None or following.string != "(": + continue + start = offsets[token.start[0] - 1] + token.start[1] + end = offsets[token.end[0] - 1] + token.end[1] + replacements.append((start, end, MINIEXPR_FUNCTION_ALIASES[token.string])) + for start, end, name in reversed(replacements): + text = text[:start] + name + text[end:] + return text.encode("utf-8") if binary else text + + # Set this to False if miniexpr should not be tried out try_miniexpr = not blosc2.IS_WASM or getattr(blosc2, "_WASM_MINIEXPR_ENABLED", False) @@ -115,6 +169,7 @@ def format_expr_scalar(value): "broadcast_to", "ceil", "clip", + "complex", "conj", "contains", "copysign", @@ -127,6 +182,7 @@ def format_expr_scalar(value): "expm1", "floor", "floor_divide", + "fmod", "greater", "greater_equal", "hypot", @@ -233,6 +289,17 @@ def format_expr_scalar(value): constructors += ["reshape"] +def _complex_from_parts(real, imag, *, out=None): + """Compatibility two-real-array complex constructor, without inf * 1j artifacts.""" + real, imag = np.broadcast_arrays(real, imag) + if np.iscomplexobj(real) or np.iscomplexobj(imag): + raise TypeError("complex() real and imaginary parts must be real") + result = np.empty(real.shape, dtype="complex128") if out is None else out + result.real = real + result.imag = imag + return result + + _NUMPY_ALIASES = { "acos": np.arccos, "acosh": np.arccosh, @@ -242,6 +309,7 @@ def format_expr_scalar(value): "atanh": np.arctanh, "atan2": np.arctan2, "concat": getattr(np, "concat", np.concatenate), + "complex": _complex_from_parts, "contains": _string_contains, "cumulative_prod": npcumprod, "cumulative_sum": npcumsum, @@ -603,6 +671,8 @@ def visit_Call(self, node): # noqa : C901 return slice_shape(obj_shape, slices) # --- Handle common chained methods on array objects --- + if base_name == "copy": + return obj_shape if obj_shape is not None else args[0] if attr_name in ("astype", "copy"): return obj_shape elif attr_name in ("flatten", "ravel"): @@ -1052,15 +1122,15 @@ def process_key(key, shape): def is_inside_ne_evaluate() -> bool: """ - Whether the current code is being executed from an ne_evaluate call + Whether execution is inside the chunk evaluator (including its legacy alias). """ # Get the current call stack stack = inspect.stack() - return builtins.any(frame_info.function in {"ne_evaluate"} for frame_info in stack) + return builtins.any(frame_info.function in {"ne_evaluate", "evaluate_chunk"} for frame_info in stack) def incomplete_lazyfunc(func) -> None: - """Decorator for lazy functions with incomplete numexpr/miniexpr coverage. + """Decorator for lazy functions requiring explicit NumPy fallback coverage. This function will force eager execution when called from ne_evaluate. @@ -1148,8 +1218,8 @@ def compute_smaller_slice(larger_shape, smaller_shape, larger_slice): # A length-1 axis broadcasts, so take its only entry whatever the # larger slice asked for -- but keep the entry's *kind*, because an # integer drops the axis and a slice keeps it. Substituting a slice - # for an integer here left the operand one rank too high, and numexpr - # then broadcast that phantom axis back into the result. + # for an integer here left the operand one rank too high, and expression + # broadcasting then introduced a phantom axis into the result. if smaller_shape[j_small] != 1: smaller_slice.append(s) else: diff --git a/src/blosc2/version.py b/src/blosc2/version.py index 241d027ca..7e3c7039c 100644 --- a/src/blosc2/version.py +++ b/src/blosc2/version.py @@ -1,2 +1,2 @@ -__version__ = "4.14.2.dev0" +__version__ = "4.15.0.dev0" __array_api_version__ = "2024.12" diff --git a/src/blosc2/zarr_source.py b/src/blosc2/zarr_source.py index 7920e623f..e487798cd 100644 --- a/src/blosc2/zarr_source.py +++ b/src/blosc2/zarr_source.py @@ -43,6 +43,12 @@ def counting_store(zarr, store, traffic, *, metadata=None): class CountingStore(zarr.storage.WrapperStore): _blosc2_traffic = traffic + def with_read_only(self, read_only=False): + # Zarr 3.1's WrapperStore inherits an unimplemented base method. + # Retain traffic/metadata accounting when Zarr opens a writable + # authorized store for reading. + return CountingStore(self._store.with_read_only(read_only)) + async def get(self, key, prototype, byte_range=None): is_metadata = ( metadata is not None diff --git a/tests/README.md b/tests/README.md new file mode 100644 index 000000000..f16dc0bc4 --- /dev/null +++ b/tests/README.md @@ -0,0 +1,101 @@ +# Compatibility test sampling + +The default suite uses `orthogonal_cases` (in `conftest.py`) for independent +compatibility dimensions rather than multiplying every dtype, operation, axis, +layout, tile size, and backend. It keeps a baseline, varies each dimension +independently, and adds mixed settings along a rotating diagonal. Every supplied +parameter value remains covered; exhaustive pairwise coverage is not promised. + +Use explicit case tables for interactions that matter numerically. In particular, +the reduction tests retain both floating widths for cancellation, product +overflow/underflow, extrema NaNs and signed zero, and empty-input identities or +errors. Compressed extrema retain every special-value case for both min and max, +with representative compiler, dtype, and root/method combinations. + +Focused regressions for security/admission, metadata, persistence, masks, +ownership, concurrency, execution routes, and integer overflow are not replaced +by generic samples. The existing opt-in `--native-semantics` qualification +matrices are unchanged. + +For the initial reduction, local default collection fell from 14,247 to 12,989 +units. The largest modules changed as follows: + +| Module | Before | After | +| --- | ---: | ---: | +| `test_menudet_arrays.py` | 408 | 67 | +| `test_native_graph_preparation.py` | 472 | 217 | +| `test_expression_graph_properties.py` | 347 | 107 | +| `test_expression_graph.py` | 467 | 342 | + +Counts depend on installed optional dependencies. The initial pass affected only +tests added since `main`. + +## General suite pass + +A subsequent pass reduced local default collection from 12,989 to 12,002 units: + +| Module | Before | After | +| --- | ---: | ---: | +| `ndarray/test_elementwise_funcs.py` | 903 | 459 | +| `test_schunk_insert.py` | 256 | 66 | +| `test_schunk_update.py` | 196 | 64 | +| `ndarray/test_auto_parts.py` | 116 | 33 | +| `ndarray/test_ndarray.py` | 314 | 269 | +| `ndarray/test_reductions.py` | 637 | 589 | +| `test_compressors.py` | 90 | 45 | + +Elementwise coverage retains every function/dtype pair, rotating 1-D and 2-D +layouts instead of crossing both with every pair. Compressor tests retain every +codec/filter pair and alternate GIL modes. Eye construction retains every +geometry/offset/dtype combination, with representative chunk layouts. Automatic +partition sanity checks sample independent compression/shape/dtype axes. + +SChunk mutations retain every storage format and all three meaningful API modes +(precompressed chunks, copied data, and non-copied data); the unused copy flag +is no longer varied for precompressed chunks. Storage/GIL/chunk-count settings +are sampled. Beginning, end, and middle positions are deterministic, and final +NumPy chunk contents are verified after insertion and replacement. Replacements +now differ from the original data rather than rewriting identical values. + +Broadcast reductions retain one of two equivalent small geometries and the +existing opt-in large geometry. Heavy elementwise matrices and focused regression +tests remain unchanged. + +`conftest.py` also isolates the process-global `set_releasegil` setting for each +test. Sampling must not make a callback test depend on which GIL parameter ran +last in an earlier module on the same xdist worker. Two isolation regression +cases bring the default local total to 12,004. + +## Local HTTP diagnostics + +Unhandled request errors from the standard-library test servers print the +exception type/message first, followed by the current test and complete +traceback. The same details are saved under +`.pytest_cache/d/http-server-errors/.log` (`master.log` without xdist). +With `-p no:cacheprovider`, logs go into a pytest temporary directory instead. +Each worker resets its log at session startup. Request errors are still logged, +not suppressed or automatically turned into test failures; inspect these files +if parallel progress output obscures a traceback from an otherwise passing run. + +## Shared fixtures and duplicate cases + +A final focused pass reduced default collection from 12,006 to 11,588 units: + +| Module | Before | After | +| --- | ---: | ---: | +| `ndarray/test_lazyexpr.py` | 898 | 742 | +| `ndarray/test_lazyexpr_fields.py` | 442 | 242 | +| `ndarray/test_reductions.py` | 589 | 563 | +| `ndarray/test_stringarrays.py` | 76 | 40 | + +Shared array fixtures now use explicit scenarios: both floating precisions still +see every original size/rank, and each default mixed-field dtype pair still sees +both sizes and both default partition relationships. Standalone dtype/shape +fixtures are unchanged. Remaining shared-fixture combinations retain their full +original coverage under `heavy`, including the NumPy 1.x short-integer skip. + +Unicode roundtrips retain all 12 distinct effective partition configurations; +the former 48-case grid repeatedly normalized wrong-rank chunk/block tuples to +`None`. Reduction-expression tests collect only valid shape/axis/operation +combinations instead of counting early returns as passes. All cases that +previously performed numerical comparisons remain covered. diff --git a/tests/conftest.py b/tests/conftest.py index 8ad4107ab..40abaac17 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -7,8 +7,11 @@ import gc import os +import socketserver import sys +import threading import time +import traceback import httpx import pytest @@ -34,10 +37,99 @@ _test_counter = 0 +def pytest_addoption(parser): + parser.addoption( + "--native-semantics", + action="store_true", + help="Run optional native semantic reference matrices (qualified primarily in miniexpr).", + ) + + +def pytest_collection_modifyitems(config, items): + if config.getoption("--native-semantics"): + return + selected = [item for item in items if item.get_closest_marker("native_semantics") is None] + deselected = [item for item in items if item.get_closest_marker("native_semantics") is not None] + items[:] = selected + if deselected: + config.hook.pytest_deselected(items=deselected) + + def expected_nthreads(nthreads: int) -> int: return 1 if blosc2.IS_WASM else nthreads +def orthogonal_cases(*dimensions): + """Sample independent parameter axes without their full Cartesian product. + + Sweep each axis with the others at their first (baseline) value, then add + a rotating diagonal to exercise mixed settings. Every value is retained, + but this deliberately does not promise exhaustive pairwise coverage. + Keep interaction-specific regressions in explicit parameter tables instead. + """ + baseline = tuple(values[0] for values in dimensions) + cases = [baseline] + for axis, values in enumerate(dimensions): + for value in values[1:]: + case = list(baseline) + case[axis] = value + cases.append(tuple(case)) + for index in range(1, max(map(len, dimensions))): + case = tuple(values[index % len(values)] for values in dimensions) + if case not in cases: + cases.append(case) + return cases + + +def report_http_server_error(log_path, client_address): + """Record the active request exception before parallel output can hide it.""" + exception_type, error, tb = sys.exc_info() + summary = "".join(traceback.format_exception_only(exception_type, error)).strip() + test = os.environ.get("PYTEST_CURRENT_TEST", "outside a running test") + message = f"HTTP request error: {summary}\nTest: {test}\nClient: {client_address!r}\n" + "".join( + traceback.format_exception(exception_type, error, tb) + ) + # Persist first: xdist/capture/teardown can interrupt or hide stderr output. + with log_path.open("a", encoding="utf-8") as stream: + stream.write(message + "\n") + sys.stderr.write(f"{message}\nFull HTTP error log: {log_path}\n") + + +@pytest.fixture(autouse=True, scope="session") +def _http_server_diagnostics(pytestconfig, tmp_path_factory): + worker = os.environ.get("PYTEST_XDIST_WORKER", "master") + cache = getattr(pytestconfig, "cache", None) + log_dir = ( + cache.mkdir("http-server-errors") + if cache is not None + else tmp_path_factory.mktemp("http-server-errors") + ) + log_path = log_dir / f"{worker}.log" + log_path.write_text("", encoding="utf-8") + lock = threading.Lock() + + def handle_error(server, request, client_address): + with lock: + report_http_server_error(log_path, client_address) + + with pytest.MonkeyPatch.context() as patch: + patch.setattr(socketserver.BaseServer, "handle_error", handle_error) + yield + + +@pytest.fixture(scope="session") +def native_graph_runtime(): + """Optional dependency feature; qualification jobs must require its presence.""" + try: + blosc2.NativeGraph.from_expression("x", {"x": "float32"}) + except NotImplementedError as error: + if os.environ.get("MENUDET_REQUIRE_GRAPH_RUNTIME") or os.environ.get( + "MENUDET_REQUIRE_ARRAY_RUNTIME" + ): + pytest.fail(str(error)) + pytest.skip("Installed miniexpr dependency does not implement native graph preparation") + + @pytest.fixture def b2z_range_reads(monkeypatch): """Exercise the large-archive range path using small, inexpensive fixtures.""" @@ -69,6 +161,20 @@ def _fast_textual_idle(): textual_wait.SLEEP_GRANULARITY = saved +@pytest.fixture(autouse=True) +def isolate_releasegil(): + """Keep process-global GIL policy from leaking into Python callback tests. + + Compression tests exercise both policies. Their final parameter must not + determine whether a later filler/prefilter runs Python without the GIL. + """ + previous = blosc2.set_releasegil(False) + try: + yield + finally: + blosc2.set_releasegil(previous) + + @pytest.fixture(autouse=True, scope="session") def _isolate_cwd_per_worker(tmp_path_factory): """Give each xdist worker its own cwd. diff --git a/tests/ctable/test_ctable_computed_cols.py b/tests/ctable/test_ctable_computed_cols.py index 9c90040ef..3d9995fc7 100644 --- a/tests/ctable/test_ctable_computed_cols.py +++ b/tests/ctable/test_ctable_computed_cols.py @@ -10,7 +10,9 @@ from __future__ import annotations import sys +from concurrent.futures import ThreadPoolExecutor from dataclasses import dataclass +from threading import Event import numpy as np import pytest @@ -18,6 +20,43 @@ import blosc2 from blosc2 import CTable + +@pytest.mark.skipif(sys.platform in {"emscripten", "wasi"}, reason="Runtime does not provide Python threads") +@pytest.mark.parametrize("computed", [False, True]) +def test_safe_column_graph_observes_update_at_controlled_read_boundary(monkeypatch, computed): + from blosc2.ctable import Column + + table = _make_invoice_table(8) + if computed: + with blosc2.expression_evaluation("safe"): + table.add_computed_column("adjusted", lambda cols: cols["qty"] + 1) + name = "adjusted" if computed else "qty" + expr = blosc2.lazyexpr("x * 2", {"x": table[name]}, evaluation="safe") + entered, resume = Event(), Event() + original = Column._values_from_key + + def paused_read(self, key): + if self._table_ref is table and self._col_name == name and not resume.is_set(): + entered.set() + assert resume.wait(10) + return original(self, key) + + monkeypatch.setattr(Column, "_values_from_key", paused_read) + # The read pauses BEFORE any native access. This exercises a permitted + # between-read change, not simultaneous native writes or snapshot isolation. + with ThreadPoolExecutor(max_workers=2) as pool: + read = pool.submit(lambda: expr[:]) + try: + assert entered.wait(10) + update = pool.submit(lambda: table["qty"].__setitem__(slice(None), np.arange(11, 19))) + update.result(timeout=10) + finally: + resume.set() + expected = (np.arange(11, 19) + int(computed)) * 2 + np.testing.assert_array_equal(read.result(timeout=10), expected) + np.testing.assert_array_equal(expr[:], expected) + + # --------------------------------------------------------------------------- # Fixtures / row types # --------------------------------------------------------------------------- @@ -72,6 +111,174 @@ def test_computed_column_dtype_override(): assert t._computed_cols["total"]["dtype"] == np.dtype(np.float32) +def test_safe_column_admission_checks_cached_expression_before_dtype(): + t = _make_invoice_table() + t.add_computed_column("total", "price * qty") + + class HostileCachedExpression: + @property + def dtype(self): + pytest.fail("Read unadmitted computed-column metadata") + + t._computed_cols["total"]["lazy"] = HostileCachedExpression() + with pytest.raises(blosc2.UnsafeDeserializationError, match="cached computed-column"): + blosc2.lazyexpr("x + 1", {"x": t["total"]}, evaluation="safe") + + +def test_safe_column_admission_rejects_unknown_recipe_kind(): + t = _make_invoice_table() + t.add_computed_column("total", "price * qty") + t._computed_cols["total"]["kind"] = "unregistered" + with pytest.raises(blosc2.UnsafeDeserializationError, match="recipe kind"): + blosc2.lazyexpr("x + 1", {"x": t["total"]}, evaluation="safe") + + +@pytest.mark.parametrize("mutation", ["expression", "dependencies", "cached_operand"]) +def test_safe_column_admission_rejects_recipe_cache_mismatch(mutation): + t = _make_invoice_table() + t.add_computed_column("total", "price * qty") + recipe = t._computed_cols["total"] + if mutation == "expression": + recipe["expression"] = "o0 + o1" + elif mutation == "dependencies": + recipe["col_deps"] = list(reversed(recipe["col_deps"])) + else: + cached = recipe["lazy"] + name = next(iter(cached.operands)) + cached.operands[name] = blosc2.asarray(cached.operands[name][:]) + with pytest.raises(ValueError, match="recipe/cache mismatch"): + blosc2.lazyexpr("x + 1", {"x": t["total"]}, evaluation="safe") + + +def test_safe_computed_column_graph_tracks_append_and_delete(): + t = _make_invoice_table(3) + t.add_computed_column("total", "price * qty") + expr = blosc2.lazyexpr("x + 1", {"x": t["total"]}, evaluation="safe") + np.testing.assert_array_equal(expr[:], [2, 5, 10]) + t.append((4.0, 4, 0.1)) + assert expr.shape == (4,) + np.testing.assert_array_equal(expr[:], [2, 5, 10, 17]) + t.delete(0) + assert expr.shape == (3,) + np.testing.assert_array_equal(expr[:], [5, 10, 17]) + + +@pytest.mark.skipif( + not getattr(blosc2.blosc2_ext, "portable_descriptor_available", lambda: False)(), + reason="Installed runtime has no draft descriptor ABI", +) +@pytest.mark.parametrize( + "mutation", ["hostile", "kernel_replacement", "artifact_replacement", "bindings", "dtype", "row_shape"] +) +def test_safe_portable_column_checks_cached_kernel_before_dtype(monkeypatch, mutation): + from test_portable_lazy import kernel + + t = _make_invoice_table(3) + t.add_computed_column("total", kernel("def k(x):\n return x + 1\n"), inputs={"x": "qty"}) + expr = blosc2.lazyexpr("x + 1", {"x": t["total"]}, evaluation="safe") + np.testing.assert_array_equal(expr[:], [3, 4, 5]) + + class Hostile: + @property + def input_dtypes(self): + pytest.fail("Read hostile portable column kernel") + + def items(self): + pytest.fail("Read hostile portable column bindings") + + def __index__(self): + pytest.fail("Coerced hostile portable row extent") + + recipe = t._computed_cols["total"] + replacement = kernel("def k(x):\n return x + 2\n") + if mutation == "hostile": + monkeypatch.setitem(recipe, "kernel", Hostile()) + elif mutation == "kernel_replacement": + monkeypatch.setitem(recipe, "kernel", replacement) + elif mutation == "artifact_replacement": + monkeypatch.setitem(recipe, "artifact", replacement.to_json()) + elif mutation == "bindings": + monkeypatch.setitem(recipe, "bindings", Hostile()) + elif mutation == "dtype": + monkeypatch.setitem(recipe, "dtype", Hostile()) + else: + monkeypatch.setitem(recipe, "row_shape", (Hostile(),)) + with pytest.raises((blosc2.UnsafeDeserializationError, ValueError)): + expr.compute() + + +@pytest.mark.skipif( + not getattr(blosc2.blosc2_ext, "portable_descriptor_available", lambda: False)(), + reason="Installed runtime has no draft descriptor ABI", +) +def test_safe_portable_column_reuses_validated_native_handle(monkeypatch): + from test_portable_lazy import kernel + + t = _make_invoice_table(3) + t.add_computed_column("total", kernel("def k(x):\n return x + 1\n"), inputs={"x": "qty"}) + monkeypatch.setattr( + blosc2.PortableKernel, + "from_json", + lambda *a, **k: pytest.fail("Recompiled admitted cached artifact"), + ) + expr = blosc2.lazyexpr("x + 1", {"x": t["total"]}, evaluation="safe") + np.testing.assert_array_equal(expr[:], [3, 4, 5]) + np.testing.assert_array_equal(expr[:], [3, 4, 5]) + + +@pytest.mark.skipif( + not getattr(blosc2.blosc2_ext, "portable_descriptor_available", lambda: False)(), + reason="Installed runtime has no draft descriptor ABI", +) +def test_safe_portable_column_metadata_does_not_evaluate_rows(monkeypatch): + from test_portable_lazy import kernel + + t = _make_invoice_table(3) + t.add_computed_column("total", kernel("def k(x):\n return x + 1\n"), inputs={"x": "qty"}) + with monkeypatch.context() as patch: + patch.setattr(type(t), "_evaluate_portable_rows", lambda *a, **k: pytest.fail("Evaluated metadata")) + assert t["total"].dtype == np.dtype("int64") + expr = blosc2.lazyexpr("x + 1", {"x": t["total"]}, evaluation="safe") + assert expr.shape == (3,) + assert expr.dtype == np.dtype("int64") + np.testing.assert_array_equal(expr[:], [3, 4, 5]) + + +def test_safe_column_admission_checks_cached_expression_operand_closure(): + t = _make_invoice_table() + t.add_computed_column("total", "price * qty") + + class HostileInput: + @property + def dtype(self): + pytest.fail("Read unadmitted computed-column input metadata") + + cached = t._computed_cols["total"]["lazy"] + cached.operands[next(iter(cached.operands))] = HostileInput() + with pytest.raises(blosc2.UnsafeDeserializationError, match="HostileInput"): + blosc2.lazyexpr("x + 1", {"x": t["total"]}, evaluation="safe") + + +@pytest.mark.parametrize("dependency", ["validity", "mask"]) +def test_safe_column_admission_checks_visibility_dependencies(dependency): + from blosc2.ctable import Column + + t = _make_invoice_table() + + class HostileVisibility: + @property + def dtype(self): + pytest.fail("Read unadmitted visibility metadata") + + column = Column(t, "price") + if dependency == "validity": + t._valid_rows = HostileVisibility() + else: + column._mask = HostileVisibility() + with pytest.raises(blosc2.UnsafeDeserializationError, match="HostileVisibility"): + blosc2.lazyexpr("x + 1", {"x": column}, evaluation="safe") + + def test_computed_column_expression_string(): t = _make_invoice_table() t.add_computed_column("total", "price * qty") @@ -719,6 +926,23 @@ def test_computed_column_open(tmp_path): np.testing.assert_allclose(arr, [1.0, 4.0, 9.0, 16.0, 25.0]) +def test_loaded_expression_recipes_keep_safe_boundary(tmp_path, monkeypatch): + import importlib + + path = str(tmp_path / "safe_recipes") + t = CTable(Invoice, [(2.0, 3, 0.1), (4.0, 5, 0.1)], urlpath=path, mode="w") + t.add_computed_column("total", "price * qty") + t.materialize_computed_column("total", new_name="stored") + module = importlib.import_module("blosc2.expression_graph") + monkeypatch.setattr(module, "eval", lambda *a: pytest.fail("Loaded recipe used eval"), raising=False) + loaded = CTable.open(path, mode="a") + assert loaded._computed_cols["total"]["lazy"]._evaluation == "safe" + assert loaded._materialized_cols["stored"]["_evaluation"] == "safe" + np.testing.assert_allclose(loaded["total"][:], [6.0, 20.0]) + loaded.append((6.0, 7, 0.1)) + np.testing.assert_allclose(loaded["stored"][:], [6.0, 20.0, 42.0]) + + def test_computed_column_open_append(tmp_path): path = str(tmp_path / "tbl") t = CTable(Invoice, [(float(i + 1), i + 1, 0.1) for i in range(3)], urlpath=path, mode="w") @@ -876,16 +1100,13 @@ def test_dsl_computed_column_no_storage(): def test_dsl_computed_column_persistence(tmp_path): - """DSL kernel source is persisted and the column is available after open.""" + """Authored computed columns persist with an explicit row-domain contract.""" t = _make_invoice_table(5) - t.add_computed_column("total", total, inputs=["price", "qty"]) + t.add_computed_column("total", total, inputs={"price": "price", "qty": "qty"}, dtype="float64") path = str(tmp_path / "tbl") t.save(path) - - t2 = blosc2.open(path) - assert "total" in t2._computed_cols - assert t2._computed_cols["total"]["kind"] == "dsl" - np.testing.assert_allclose(t2["total"][:], [1.0, 4.0, 9.0, 16.0, 25.0]) + restored = blosc2.CTable.open(path) + np.testing.assert_allclose(restored["total"][:], [1, 4, 9, 16, 25]) def test_dsl_computed_column_inputs_mismatch_raises(): @@ -982,17 +1203,14 @@ def test_dsl_generated_column_autofill_append(): def test_dsl_generated_column_persistence_and_append(tmp_path): - """DSL generated column survives save/open and auto-fills after reload.""" + """Authored row transformers persist and refill appended rows natively.""" t = _make_invoice_table(3) - t.add_generated_column("total", values=total, inputs=["price", "qty"]) + t.add_generated_column("total", values=total, inputs={"price": "price", "qty": "qty"}, dtype="float64") path = str(tmp_path / "tbl") t.save(path) - - t2 = blosc2.open(path, mode="a") - assert "total" in t2._materialized_cols - assert t2._materialized_cols["total"]["transformer_kind"] == "dsl" - t2.append((4.0, 4, 0.1)) - np.testing.assert_allclose(t2["total"][:], [1.0, 4.0, 9.0, 16.0]) + restored = blosc2.CTable.open(path, mode="a") + restored.append((4.0, 4, 0.1)) + np.testing.assert_allclose(restored["total"][:], [1.0, 4.0, 9.0, 16.0]) def test_dsl_generated_column_refresh(tmp_path): @@ -1011,8 +1229,8 @@ def test_dsl_generated_column_refresh(tmp_path): @pytest.mark.skipif(sys.platform == "win32", reason="cc backend requires a system C compiler") -def test_dsl_jit_backend_persisted_in_schema(): - """jit_backend set via lazyudf() is stored in the column schema.""" +def test_dsl_jit_backend_not_persisted_in_portable_schema(): + """A local JIT preference does not become a portable execution requirement.""" t = _make_invoice_table(3) t.add_generated_column( "total", @@ -1020,12 +1238,14 @@ def test_dsl_jit_backend_persisted_in_schema(): ) schema = t._schema_dict_with_computed() mat = {m["name"]: m for m in schema["materialized_columns"]} - assert mat["total"]["jit_backend"] == "cc" + assert mat["total"]["transformer_kind"] == "portable" + assert "jit_backend" not in mat["total"] + assert "dsl_source" not in mat["total"] @pytest.mark.skipif(sys.platform == "win32", reason="cc backend requires a system C compiler") -def test_dsl_jit_backend_restored_after_open(tmp_path): - """jit_backend is restored from schema on open and used for auto-fill.""" +def test_dsl_jit_backend_falls_back_after_portable_open(tmp_path): + """A local backend preference allows native portable persistence/fallback.""" t = _make_invoice_table(3) t.add_generated_column( "total", @@ -1033,11 +1253,10 @@ def test_dsl_jit_backend_restored_after_open(tmp_path): ) path = str(tmp_path / "tbl") t.save(path) - - t2 = blosc2.open(path, mode="a") - assert t2._materialized_cols["total"].get("jit_backend") == "cc" - t2.append((4.0, 4, 0.1)) - np.testing.assert_allclose(t2["total"][:], [1.0, 4.0, 9.0, 16.0]) + restored = blosc2.CTable.open(path, mode="a") + restored.append({"price": 4.0, "qty": 4}) + np.testing.assert_allclose(restored["total"][:], [1.0, 4.0, 9.0, 16.0]) + restored.close() def test_dsl_no_jit_backend_not_in_schema(): diff --git a/tests/ctable/test_ctable_concurrency.py b/tests/ctable/test_ctable_concurrency.py new file mode 100644 index 000000000..d5af7472a --- /dev/null +++ b/tests/ctable/test_ctable_concurrency.py @@ -0,0 +1,132 @@ +"""Bounded native-read probes; unsupported races run only via the explicit CLI. + +Run this file with MODE MUTATION unsafe to investigate an unprotected +race in a disposable subprocess. Default pytest tests only caller serialization. +""" + +from __future__ import annotations + +import json +import subprocess +import sys +from concurrent.futures import ThreadPoolExecutor +from dataclasses import dataclass +from pathlib import Path +from threading import Event, Lock, get_ident + +import numpy as np +import pytest + +import blosc2 + + +def native_read_probe(mode, mutation, serialized=True): + @dataclass + class Row: + x: int = blosc2.field(blosc2.int64(), chunks=(32,), blocks=(8,)) + + table = blosc2.CTable(Row, [(i,) for i in range(64)], expected_size=64) + # Fill the actual capacity: append must enter native resize, not spare space. + while len(table) < len(table._valid_rows): + table.append([len(table)]) + n = len(table) + raw = table._cols["x"] + old_shape = raw.shape + expr = blosc2.lazyexpr("x * 2", {"x": table["x"]}, evaluation=mode) + entered, resume, attempted, written = Event(), Event(), Event(), Event() + operation_lock = Lock() + reader_ident = None + raw.schunk.dparams = blosc2.DParams(nthreads=1) + + @raw.schunk.postfilter(np.int64, np.int64) + def pause_inside_decompression(input, output, offset): + output[:] = input + if get_ident() == reader_ident and not entered.is_set(): + entered.set() + assert resume.wait(10), "native read was not resumed" + + def read(): + nonlocal reader_ident + reader_ident = get_ident() + if serialized: + with operation_lock: + return expr[:] + return expr[:] + + def update(): + if serialized: + # Deterministic contention evidence, not a sleep-based assertion. + assert not operation_lock.acquire(blocking=False) + attempted.set() + if serialized: + operation_lock.acquire() + try: + if mutation == "overwrite": + table["x"][0] = 91 + else: + table.append([91]) + assert raw.shape[0] > old_shape[0] + written.set() + finally: + if serialized: + operation_lock.release() + + try: + with ThreadPoolExecutor(max_workers=2) as pool: + reading = pool.submit(read) + writing = None + try: + assert entered.wait(10), "no postfilter inside the native read" + writing = pool.submit(update) + assert attempted.wait(10), "writer did not attempt access" + if serialized: + assert not written.is_set() + else: + writing.result(timeout=10) + assert written.is_set() + assert not resume.is_set() + print("WRITE_COMPLETED_INSIDE_NATIVE_READ", flush=True) + finally: + resume.set() + values = reading.result(timeout=10) + if writing is not None: + writing.result(timeout=10) + if serialized: + np.testing.assert_array_equal(values, np.arange(n) * 2) + current = np.arange(n + int(mutation == "append")) + current[0 if mutation == "overwrite" else -1] = 91 + # A full-mode graph can retain its original shape; use a fresh graph + # for the post-append check rather than changing that existing contract. + fresh = blosc2.lazyexpr("x * 2", {"x": table["x"]}, evaluation=mode) + np.testing.assert_array_equal(fresh[:], current * 2) + return { + "native_overlap": not serialized, + "rows_read": len(values), + "rows_now": len(table), + "read_matches_before": bool(np.array_equal(values, np.arange(n) * 2)), + "read_matches_after_original_extent": bool(np.array_equal(values, current[:n] * 2)), + "read_first_values": values[:8].tolist(), + } + finally: + raw.schunk.remove_postfilter("pause_inside_decompression") + table.close() + + +@pytest.mark.skipif(sys.platform in {"emscripten", "wasi"}, reason="Requires threads and subprocesses") +@pytest.mark.parametrize("mode", ["safe", "full"]) +@pytest.mark.parametrize("mutation", ["overwrite", "append"]) +def test_caller_lock_serializes_native_table_read_and_mutation(mode, mutation): + result = subprocess.run( + [sys.executable, "-X", "faulthandler", str(Path(__file__).resolve()), mode, mutation, "serialized"], + capture_output=True, + text=True, + timeout=45, + check=False, + ) + assert result.returncode == 0, result.stdout + result.stderr + report = json.loads(result.stdout.strip()) + assert report["native_overlap"] is False + + +if __name__ == "__main__": + print(json.dumps(native_read_probe(sys.argv[1], sys.argv[2], sys.argv[3] != "unsafe"))) diff --git a/tests/ctable/test_ctable_dsl_columns.py b/tests/ctable/test_ctable_dsl_columns.py index 6aaf5c2b0..cc40bb363 100644 --- a/tests/ctable/test_ctable_dsl_columns.py +++ b/tests/ctable/test_ctable_dsl_columns.py @@ -86,6 +86,13 @@ def test_dsl_computed_callable_lazyudf_form(): np.testing.assert_array_equal(np.asarray(t["r"][:]), np.arange(20) + 20) +def test_assign_dsl_lazyudf_uses_portable_rows(): + t = _make_table() + view = t.assign(r=blosc2.lazyudf(k_loop, (t.a, t.b), dtype=np.int64)) + assert view._computed_cols["r"]["kind"] == "portable" + np.testing.assert_array_equal(view["r"][:], np.arange(20) + 20) + + def test_dsl_computed_partial_slice(): t = _make_table() t.add_computed_column("r", k_add, inputs=["a", "b"]) @@ -152,23 +159,17 @@ def test_dsl_computed_in_where_streams_multichunk(): def test_dsl_computed_roundtrip(tmp_path): path = str(tmp_path / "dsl.b2d") t = _make_table(urlpath=path, mode="w") - t.add_computed_column("r", k_loop, inputs=["a", "b"]) + t.add_computed_column("r", k_loop, inputs={"x": "a", "y": "b"}) t.close() - # Stored schema carries kind:dsl + dsl_source and no expression. + # New registration stores an artifact rather than Python source. meta = blosc2.open(f"{path}/_meta.b2f") sd = json.loads(meta.vlmeta["schema"]) - (cc,) = sd["computed_columns"] - assert cc["kind"] == "dsl" - assert "dsl_source" in cc - assert "expression" not in cc + assert sd["computed_columns"][0]["kind"] == "portable" + assert "dsl_source" not in sd["computed_columns"][0] t2 = blosc2.open(path) - np.testing.assert_array_equal(np.asarray(t2["r"][:]), np.arange(20) + 20) - a = np.arange(20) - r = a + 20 - sel = t2.where("(r > 25) & (a < 18)")[:] - assert len(sel) == int(((r > 25) & (a < 18)).sum()) + np.testing.assert_array_equal(t2["r"][:], np.arange(20) + 20) t2.close() @@ -230,15 +231,14 @@ def test_dsl_generated_create_index(): def test_dsl_generated_roundtrip(tmp_path): path = str(tmp_path / "gen.b2d") t = _make_table(n=10, urlpath=path, mode="w") - t.add_generated_column("g", values=k_add, inputs=["a", "b"], dtype=blosc2.int64()) + t.add_generated_column("g", values=k_add, inputs={"x": "a", "y": "b"}, dtype=blosc2.int64()) t.close() meta = blosc2.open(f"{path}/_meta.b2f") sd = json.loads(meta.vlmeta["schema"]) - (m,) = sd["materialized_columns"] - assert m["transformer_kind"] == "dsl" - assert "dsl_source" in m + assert sd["materialized_columns"][0]["transformer_kind"] == "portable" + assert "dsl_source" not in sd["materialized_columns"][0] t2 = blosc2.open(path) - np.testing.assert_array_equal(np.asarray(t2["g"][:]), np.arange(10) + 10) + np.testing.assert_array_equal(t2["g"][:], np.arange(10) + 10) t2.close() diff --git a/tests/ctable/test_dictionary_column.py b/tests/ctable/test_dictionary_column.py index 4b112bd99..fd2cbd7a8 100644 --- a/tests/ctable/test_dictionary_column.py +++ b/tests/ctable/test_dictionary_column.py @@ -8,6 +8,8 @@ from __future__ import annotations +import subprocess +import sys from dataclasses import dataclass import numpy as np @@ -370,6 +372,31 @@ def test_import_dict_uint32(self): ct = CTable.from_arrow(at.schema, at.to_batches()) assert ct["vendor"][:] == ["Uber", "Lyft", "Uber", None] + def test_import_unsigned_dictionary_without_pandas(self): + script = """ +from importlib.abc import MetaPathFinder +import sys + +class NoPandas(MetaPathFinder): + def find_spec(self, fullname, path, target=None): + if fullname == 'pandas' or fullname.startswith('pandas.'): + raise ModuleNotFoundError("pandas intentionally unavailable", name=fullname) + +sys.meta_path.insert(0, NoPandas()) +import pyarrow as pa +from blosc2 import CTable + +for dtype in (pa.uint8(), pa.uint32()): + for codes in ([0, None], [None, None], []): + indices = pa.array(codes, type=dtype) + column = pa.DictionaryArray.from_arrays(indices, pa.array(['A'])) + table = pa.table({'vendor': column}) + result = CTable.from_arrow(table.schema, table.to_batches()) + assert result['vendor'][:] == ['A' if code == 0 else None for code in codes] +""" + result = subprocess.run([sys.executable, "-c", script], capture_output=True, text=True) + assert result.returncode == 0, result.stderr + def test_import_dict_uint_exceeding_int32_raises(self): import numpy as np diff --git a/tests/ctable/test_null_channel.py b/tests/ctable/test_null_channel.py index aba2a04b2..534fdf46c 100644 --- a/tests/ctable/test_null_channel.py +++ b/tests/ctable/test_null_channel.py @@ -269,7 +269,8 @@ class Row: np.testing.assert_array_equal(col.is_null(), [False, True]) -def test_null_pred_matches_is_null_for_sentinel_column(): +@pytest.mark.parametrize("identity_equal", [False, True]) +def test_null_pred_matches_is_null_for_sentinel_column(monkeypatch, identity_equal): @dataclass class Row: v: int = blosc2.field(blosc2.int64(null_value=-1)) @@ -277,6 +278,7 @@ class Row: t = CTable(Row) t.extend({"v": [1, -1, 3]}) col = t["v"] + monkeypatch.setattr(blosc2, "_disable_overloaded_equal", identity_equal) pred = np.asarray(col._nulls.null_pred().compute()[:]) np.testing.assert_array_equal(pred[: t.nrows], col.is_null()) valid = np.asarray(col._nulls.valid_pred().compute()[:]) diff --git a/tests/ctable/test_null_storage_schema.py b/tests/ctable/test_null_storage_schema.py index 10bf1287d..98ca96ad2 100644 --- a/tests/ctable/test_null_storage_schema.py +++ b/tests/ctable/test_null_storage_schema.py @@ -28,6 +28,13 @@ from blosc2.schema import fill_value_for from blosc2.schema_compiler import schema_from_dict, schema_to_dict + +@pytest.mark.skipif(HAVE_UTF8, reason="Runtime supports UTF-8 StringDType columns") +def test_utf8_rejects_runtime_without_string_dtype(): + with pytest.raises(TypeError, match=r"utf8 columns require NumPy >= 2\.0"): + blosc2.utf8() + + # --------------------------------------------------------------------------- # Spec-level declaration # --------------------------------------------------------------------------- diff --git a/tests/ctable/test_pandas_arrow_import.py b/tests/ctable/test_pandas_arrow_import.py index faca89945..915eaf161 100644 --- a/tests/ctable/test_pandas_arrow_import.py +++ b/tests/ctable/test_pandas_arrow_import.py @@ -13,6 +13,9 @@ pd = pytest.importorskip("pandas") pa = pytest.importorskip("pyarrow") +if not hasattr(np.dtypes, "StringDType"): + pytest.skip("utf8 columns require NumPy >= 2.0 (StringDType)", allow_module_level=True) + def make_frame(arrow_backed, missing=False): df = pd.DataFrame( diff --git a/tests/ctable/test_remote_ctable.py b/tests/ctable/test_remote_ctable.py index 1dfee1f42..c905ac82b 100644 --- a/tests/ctable/test_remote_ctable.py +++ b/tests/ctable/test_remote_ctable.py @@ -12,6 +12,7 @@ import numpy as np import pytest +from utf8_compat import needs_utf8, utf8_spec import blosc2 @@ -41,7 +42,7 @@ def remote_table_url(tmp_path, table, name="table"): return url -@pytest.mark.parametrize("text_spec", [blosc2.utf8(), blosc2.vlstring()]) +@pytest.mark.parametrize("text_spec", [pytest.param(utf8_spec(), marks=needs_utf8), blosc2.vlstring()]) def test_preview_opens_only_visible_columns(tmp_path, monkeypatch, text_spec): @dataclasses.dataclass class WideRow: @@ -581,10 +582,14 @@ def test_remote_full_index_selective_lookup(tmp_path, expression, expected): @pytest.mark.parametrize("kind", ["partial", "opsi", "bucket"]) def test_remote_positional_index_lookup(tmp_path, kind): - url, _ = indexed_remote_table_url(tmp_path, kind, rows=5000) + rows = 1025 # Five 256-row chunks, with a partial final chunk. + url, _ = indexed_remote_table_url(tmp_path, kind, rows=rows) with blosc2.RemoteCTable(url, cache_policy=blosc2.CachePolicy.MEMORY) as remote: - np.testing.assert_array_equal(remote.where("x == 7").y[:], [4993]) - np.testing.assert_array_equal(remote.where("(x >= 7) & (x < 10)").y[:], [4993, 4992, 4991]) + np.testing.assert_array_equal(remote.where("x == 7").y[:], [rows - 7]) + # Cross a chunk boundary, and check the partial tail and an empty result. + np.testing.assert_array_equal(remote.where("(x >= 255) & (x < 258)").y[:], [770, 769, 768]) + np.testing.assert_array_equal(remote.where("x == 1024").y[:], [1]) + np.testing.assert_array_equal(remote.where("x == 1025").y[:], []) assert any(f"_indexes/x/{kind}." in (array.dataset or "") for array in remote._storage._arrays) @@ -671,6 +676,7 @@ def test_sparse_table_cache_budget(tmp_path, limit): @pytest.mark.parametrize("include_note", [False, True]) @pytest.mark.parametrize("nrows", [0, 2, 20, 21]) +@needs_utf8 def test_remote_example_total_timing(tmp_path, capsys, include_note, nrows): import runpy from pathlib import Path @@ -700,6 +706,7 @@ def test_remote_example_total_timing(tmp_path, capsys, include_note, nrows): assert sample == str(local[start:stop]).strip() +@needs_utf8 def test_remote_example_cache_dir(tmp_path, capsys, monkeypatch): import runpy import sys @@ -719,6 +726,7 @@ def test_remote_example_cache_dir(tmp_path, capsys, monkeypatch): assert "(0 requests," in output.split("Total network :")[1] +@needs_utf8 def test_remote_example_batch_columns(tmp_path, capsys): import runpy from pathlib import Path @@ -747,6 +755,7 @@ def test_remote_example_batch_columns(tmp_path, capsys): @pytest.mark.parametrize(("format_flag", "suffix"), [("pytables", ".h5"), ("parquet", ".parquet")]) @pytest.mark.parametrize("explicit", [False, True]) +@needs_utf8 def test_remote_example_external_formats(tmp_path, capsys, monkeypatch, format_flag, suffix, explicit): import runpy import sys @@ -803,6 +812,7 @@ def test_remote_example_external_formats(tmp_path, capsys, monkeypatch, format_f @pytest.mark.parametrize("explicit", [False, True]) +@needs_utf8 def test_remote_example_blosc2_flag_and_inference(tmp_path, capsys, monkeypatch, explicit): import runpy import sys @@ -821,6 +831,7 @@ def test_remote_example_blosc2_flag_and_inference(tmp_path, capsys, monkeypatch, assert "[Format: Blosc2 B2Z" in capsys.readouterr().out +@needs_utf8 def test_remote_example_unknown_extension(tmp_path, monkeypatch, capsys): import runpy import sys @@ -835,6 +846,7 @@ def test_remote_example_unknown_extension(tmp_path, monkeypatch, capsys): assert "cannot infer format" in capsys.readouterr().err +@needs_utf8 def test_remote_example_url_extension_ignores_query_string(monkeypatch): import runpy import sys @@ -881,6 +893,7 @@ def changed_info(self, path, **kwargs): @pytest.mark.parametrize("max_concurrency", [1, 8]) @pytest.mark.parametrize("legacy", [False, True]) @pytest.mark.usefixtures("b2z_range_reads") +@needs_utf8 def test_disk_cache_reuses_ctable_bootstrap(tmp_path, monkeypatch, max_concurrency, legacy): schema = dataclasses.make_dataclass("Sample", [("x", float), ("note", str, blosc2.field(blosc2.utf8()))]) values = np.random.default_rng(42).random(20_000) @@ -981,6 +994,7 @@ def unexpected_read(*args, **kwargs): @pytest.mark.parametrize( "policy", [blosc2.CachePolicy.NONE, blosc2.CachePolicy.MEMORY, blosc2.CachePolicy.DISK] ) +@needs_utf8 def test_remote_ctable_refresh(tmp_path, policy): schema = dataclasses.make_dataclass("Sample", [("x", int), ("note", str, blosc2.field(blosc2.utf8()))]) local = blosc2.CTable(schema, [(1, "old"), (2, "café")], create_summary_index=False) @@ -1503,6 +1517,7 @@ def test_remote_store_returns_table_with_independent_lifetime(tmp_path): @pytest.mark.usefixtures("b2z_range_reads") +@needs_utf8 def test_remote_ctable_reference_save_roundtrip(tmp_path): @dataclasses.dataclass class TextRow: @@ -1677,6 +1692,7 @@ class Mixed: @pytest.mark.parametrize("policy", list(blosc2.CachePolicy)) @pytest.mark.parametrize("null_storage", ["mask", "sentinel"]) @pytest.mark.parametrize("deleted", [False, True]) +@needs_utf8 def test_remote_ctable_utf8(tmp_path, policy, null_storage, deleted): @dataclasses.dataclass class TextRow: @@ -1805,6 +1821,7 @@ def test_remote_ctable_deleted_rows_and_disk_cache(tmp_path): @pytest.mark.parametrize("empty", [False, True]) +@needs_utf8 def test_remote_utf8_nested_lifetime(tmp_path, empty): @dataclasses.dataclass class TextRow: @@ -1842,6 +1859,7 @@ class TextRow: @pytest.mark.parametrize("bad_data", [None, np.arange(4, dtype="int64")]) +@needs_utf8 def test_remote_utf8_invalid_companion(tmp_path, bad_data): @dataclasses.dataclass class TextRow: @@ -1877,6 +1895,7 @@ class TextRow: @pytest.mark.parametrize("policy", list(blosc2.CachePolicy)) @pytest.mark.parametrize("blocks", [False, True]) @pytest.mark.usefixtures("b2z_range_reads") +@needs_utf8 def test_remote_utf8_bounded_transfer(tmp_path, monkeypatch, policy, blocks): from blosc2 import proxy_source from blosc2._utf8_array import UTF8Array @@ -1969,6 +1988,7 @@ def test_remote_store_rejects_table_root(tmp_path): @pytest.mark.parametrize("policy", list(blosc2.CachePolicy)) +@needs_utf8 def test_open_dispatches_local_and_remote_tables(tmp_path, policy): @dataclasses.dataclass class TextRow: @@ -2061,6 +2081,7 @@ def counted(self, path, start=None, end=None, **kwargs): @pytest.mark.usefixtures("b2z_range_reads") +@needs_utf8 def test_parallel_metadata_benchmark(tmp_path, monkeypatch): import runpy import time @@ -2139,11 +2160,8 @@ def fail(*args): assert repr(list(table[:5])) == expected[1] -@pytest.mark.parametrize( - "policy", [blosc2.CachePolicy.NONE, blosc2.CachePolicy.MEMORY, blosc2.CachePolicy.DISK] -) -@pytest.mark.parametrize("budget", [128, 1 << 20]) -def test_parallel_rows_cache_policies(tmp_path, policy, budget): +@pytest.fixture(scope="module") +def parallel_rows_archive(tmp_path_factory): @dataclasses.dataclass class Mixed: x: int = blosc2.field(blosc2.int64(null_storage="mask")) @@ -2159,7 +2177,22 @@ class Mixed: create_summary_index=False, ) local.delete([2, 9]) - url = remote_table_url(tmp_path, local) + archive = tmp_path_factory.mktemp("parallel-rows") / "table.b2z" + local.to_b2z(archive) + return local, archive.read_bytes() + + +@pytest.mark.parametrize( + "policy", [blosc2.CachePolicy.NONE, blosc2.CachePolicy.MEMORY, blosc2.CachePolicy.DISK] +) +@pytest.mark.parametrize("budget", [128, 1 << 20]) +@needs_utf8 +def test_parallel_rows_cache_policies(tmp_path, parallel_rows_archive, policy, budget): + # Reuse only immutable source bytes; each case gets a distinct URL and fresh + # caches, so no policy/budget case can benefit from another one's warm reads. + local, archive = parallel_rows_archive + url = f"memory://{tmp_path.name}-parallel-rows.b2z" + fsspec.filesystem("memory").pipe(url, archive) options = {"cache_policy": policy, "row_buffer_bytes": budget, "metadata_buffer_bytes": budget} if policy == blosc2.CachePolicy.DISK: options["cache_dir"] = tmp_path / "cache" @@ -2303,6 +2336,7 @@ def write(self, *args): assert list(table[399990:]) == list(local[399990:]) +@needs_utf8 def test_parallel_timestamp_and_projection(tmp_path): @dataclasses.dataclass class Timed: diff --git a/tests/ctable/test_remote_parquet.py b/tests/ctable/test_remote_parquet.py index 94eab2c69..d69a64ad9 100644 --- a/tests/ctable/test_remote_parquet.py +++ b/tests/ctable/test_remote_parquet.py @@ -28,6 +28,109 @@ def test_windows_cache_directory_uses_source_basename(): assert cache_directory_name(r"C:\data\source.parquet", b"cache").startswith("source.parquet--") +@pytest.mark.parametrize("view", ["raw", "public"]) +def test_safe_parquet_operand_checks_metadata_without_row_group_reads(tmp_path, monkeypatch, view): + path = tmp_path / "numeric.parquet" + pq.write_table(pa.table({"x": [1.0, 2.0, 3.0]}), path, row_group_size=1) + with blosc2.open(path, lazy=True) as remote: + column = remote._cols["x"] if view == "raw" else remote["x"] + with monkeypatch.context() as patch: + patch.setattr( + remote_parquet._ParquetColumn, + "__getitem__", + lambda *a, **k: pytest.fail("Read during admission"), + ) + expr = blosc2.lazyexpr("sqrt(x)", {"x": column}, evaluation="safe") + assert expr.shape == (3,) + assert expr.dtype == np.dtype("float64") + np.testing.assert_allclose(expr[:], np.sqrt([1.0, 2.0, 3.0])) + + +@pytest.mark.parametrize("state", ["closed", "stale", "metadata"]) +def test_safe_parquet_operand_rejects_invalid_lifetime_before_reads(tmp_path, monkeypatch, state): + path = tmp_path / "numeric.parquet" + pq.write_table(pa.table({"x": [1.0, 2.0, 3.0]}), path) + with blosc2.open(path, lazy=True) as remote: + column = remote._cols["x"] + expr = blosc2.lazyexpr("sqrt(x)", {"x": column}, evaluation="safe") + monkeypatch.setattr( + remote_parquet._ParquetColumn, "__getitem__", lambda *a, **k: pytest.fail("Read invalid column") + ) + if state == "closed": + column.storage.close() + elif state == "stale": + column.storage._generation += "-stale" + else: + column.shape = (4,) + with pytest.raises((RuntimeError, ValueError)): + expr.compute() + + +@pytest.mark.parametrize( + "dependency", ["storage", "owner", "cache", "lock", "schema", "coordinator", "dtype", "shape"] +) +def test_safe_parquet_operand_rejects_hostile_dependencies_before_hooks(tmp_path, monkeypatch, dependency): + path = tmp_path / "numeric.parquet" + pq.write_table(pa.table({"x": [1.0, 2.0, 3.0]}), path) + with blosc2.open(path, lazy=True) as remote: + column = remote._cols["x"] + expr = blosc2.lazyexpr("sqrt(x)", {"x": column}, evaluation="safe") + + class HostileDependency: + @property + def generation(self): + pytest.fail("Read unadmitted owner metadata") + + def __enter__(self): + pytest.fail("Entered hostile Parquet lock") + + def __iter__(self): + pytest.fail("Iterated hostile Parquet metadata") + + def __eq__(self, other): + pytest.fail("Compared hostile Parquet dtype") + + with monkeypatch.context() as patch: + if dependency == "storage": + patch.setattr(column, "storage", HostileDependency()) + elif dependency == "owner": + patch.setattr(column.storage, "_owner", HostileDependency()) + elif dependency == "cache": + patch.setattr(column.storage._owner, "parquet_cache", HostileDependency()) + elif dependency == "lock": + patch.setattr(column.storage._owner, "lock", HostileDependency()) + elif dependency == "schema": + patch.setattr(column.storage, "schema", HostileDependency()) + elif dependency == "coordinator": + patch.setattr(column.storage._owner, "cache_coordinator", HostileDependency()) + elif dependency == "dtype": + patch.setattr(column, "dtype", HostileDependency()) + else: + patch.setattr(column, "shape", HostileDependency()) + with pytest.raises(blosc2.UnsafeDeserializationError): + expr.compute() + + +def test_safe_parquet_operand_rejects_same_metadata_storage_rebinding(tmp_path, monkeypatch): + first, second = tmp_path / "first.parquet", tmp_path / "second.parquet" + pq.write_table(pa.table({"x": [1.0, 2.0, 3.0]}), first) + pq.write_table(pa.table({"x": [4.0, 5.0, 6.0]}), second) + with blosc2.open(first, lazy=True) as left, blosc2.open(second, lazy=True) as right: + column = left._cols["x"] + expr = blosc2.lazyexpr("sqrt(x)", {"x": column}, evaluation="safe") + monkeypatch.setattr(column, "storage", right._cols["x"].storage) + with pytest.raises(ValueError, match="storage was rebound"): + expr.compute() + + +def test_safe_parquet_ndarray_operand_rejects_unreviewed_row_shape(tmp_path): + path = tmp_path / "cells.parquet" + pq.write_table(pa.table({"x": pa.array([[1, 2], [3, 4]], type=pa.list_(pa.int32(), 2))}), path) + with blosc2.open(path, lazy=True) as remote: + with pytest.raises(blosc2.UnsafeDeserializationError, match="registered expression adapter"): + blosc2.lazyexpr("sqrt(x)", {"x": remote._cols["x"]}, evaluation="safe") + + def test_source_url_preserves_non_sensitive_query(): from blosc2.remote_store import public_source_url @@ -1108,6 +1211,55 @@ def test_oversized_memory_group_is_not_retained(tmp_path): assert remote.traffic.requests > before +@pytest.mark.skipif(sys.platform in {"emscripten", "wasi"}, reason="Runtime does not provide Python threads") +@pytest.mark.parametrize( + "policy", [blosc2.CachePolicy.NONE, blosc2.CachePolicy.MEMORY, blosc2.CachePolicy.DISK] +) +def test_safe_parquet_graph_refresh_waits_for_read_and_invalidates_old_graph(tmp_path, monkeypatch, policy): + path = tmp_path / "safe-refresh.parquet" + pq.write_table(pa.table({"x": [1.0, 2.0, 3.0, 4.0]}), path, row_group_size=2) + options = {"cache_dir": tmp_path / "cache"} if policy is blosc2.CachePolicy.DISK else {} + with blosc2.open(path, cache_policy=policy, **options) as remote: + owner = remote._remote_storage()._owner + expr = blosc2.lazyexpr("sqrt(x) + 1", {"x": remote["x"]}, evaluation="safe") + original_group = owner.group + entered, resume, updating = threading.Event(), threading.Event(), threading.Event() + + @contextmanager + def paused_group(number, physical): + with original_group(number, physical) as table: + if number == 0: + entered.set() + assert resume.wait(10) + yield table + + monkeypatch.setattr(owner, "group", paused_group) + + def refresh(): + updating.set() + remote.refresh() + + with ThreadPoolExecutor(max_workers=2) as pool: + read = pool.submit(lambda: expr[:]) + try: + assert entered.wait(10) + acquired = owner.lock.acquire(blocking=False) + if acquired: + owner.lock.release() + assert not acquired + update = pool.submit(refresh) + assert updating.wait(10) + assert not update.done() + finally: + resume.set() + np.testing.assert_allclose(read.result(timeout=10), np.sqrt([1.0, 2.0, 3.0, 4.0]) + 1) + update.result(timeout=10) + with pytest.raises(RuntimeError, match=r"closed|stale"): + expr.compute() + replacement = blosc2.lazyexpr("sqrt(x) + 1", {"x": remote["x"]}, evaluation="safe") + np.testing.assert_allclose(replacement[:], np.sqrt([1.0, 2.0, 3.0, 4.0]) + 1) + + @pytest.mark.parametrize(("workers", "budget", "expected"), [(1, 1 << 20, 1), (3, 1 << 20, 3), (3, 1, 1)]) @pytest.mark.parametrize( "policy", [blosc2.CachePolicy.MEMORY, blosc2.CachePolicy.NONE, blosc2.CachePolicy.DISK] diff --git a/tests/ndarray/safer_jit_probe.py b/tests/ndarray/safer_jit_probe.py index 82c7e7254..16f86cccf 100644 --- a/tests/ndarray/safer_jit_probe.py +++ b/tests/ndarray/safer_jit_probe.py @@ -16,9 +16,16 @@ def kernel(x): def main(): - backend, mode = sys.argv[1:] + backend, mode = sys.argv[1:3] + workload = sys.argv[3] if len(sys.argv) > 3 else "all" jit = mode != "off" kwargs = {"jit": jit, "jit_backend": backend} + if workload == "cache": + x = np.arange(16, dtype=np.float64) + arr = blosc2.asarray(x) + result = (arr * 2 + 1).compute(**kwargs) + np.testing.assert_array_equal(result[:], x * 2 + 1) + return a = blosc2.arange(0, 128, **kwargs) np.testing.assert_array_equal(a[:], np.arange(128)) a = blosc2.linspace(0, 10, 128, **kwargs) diff --git a/tests/ndarray/test_auto_parts.py b/tests/ndarray/test_auto_parts.py index 97d9de444..ae5124d28 100644 --- a/tests/ndarray/test_auto_parts.py +++ b/tests/ndarray/test_auto_parts.py @@ -10,6 +10,7 @@ import pytest import blosc2 +from conftest import orthogonal_cases ################# Automatic compute of optional chunks and blocks ################# # The exact outcome of these depends on many aspects, including CPUs cache sizes, @@ -18,18 +19,15 @@ ################################################################################### -@pytest.mark.parametrize("clevel", [0, 1, 5, 9]) -@pytest.mark.parametrize("codec", [blosc2.Codec.BLOSCLZ, blosc2.Codec.ZSTD]) @pytest.mark.parametrize( - "shape", - [ - (1000, 1000), - (10, 20, 30), - (10, 30, 50, 10), - (10, 10, 10, 10, 10), - ], + ("clevel", "codec", "shape", "dtype"), + orthogonal_cases( + [0, 1, 5, 9], + [blosc2.Codec.BLOSCLZ, blosc2.Codec.ZSTD], + [(1000, 1000), (10, 20, 30), (10, 30, 50, 10), (10, 10, 10, 10, 10)], + ["u1", "i4", "f8"], + ), ) -@pytest.mark.parametrize("dtype", ["u1", "i4", "f8"]) def test_compute_chunks_blocks(clevel, codec, shape: tuple, dtype): cparams = blosc2.cparams_dflts.copy() cparams["clevel"] = clevel diff --git a/tests/ndarray/test_dsl_kernels.py b/tests/ndarray/test_dsl_kernels.py index 3d6097fe0..98bb2c74b 100644 --- a/tests/ndarray/test_dsl_kernels.py +++ b/tests/ndarray/test_dsl_kernels.py @@ -43,6 +43,7 @@ def _probe(a): JIT_AVAILABLE = _jit_backend_available() +native_portable = pytest.mark.skipif(blosc2.IS_WASM, reason="Tests native Menudet dispatch") def _expect_jit(status): @@ -260,6 +261,7 @@ def test_kernel_integer_ops_kept_as_dsl(): np.testing.assert_equal(res[...], expected) +@native_portable def test_dsl_kernel_index_symbols_keep_full_kernel(monkeypatch): assert kernel_index_ramp.dsl_source is not None assert "def kernel_index_ramp(x):" in kernel_index_ramp.dsl_source @@ -279,11 +281,9 @@ def wrapped_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None, expr = blosc2.lazyudf(kernel_index_ramp, (x2,), dtype=np.float32) res = expr[:] - assert captured["calls"] >= 1 - assert "def kernel_index_ramp(x):" in captured["expr"] - assert "_i0" in captured["expr"] - assert "_n1" in captured["expr"] - assert "_i1" in captured["expr"] + assert captured["calls"] == 0 + assert expr._native_execution_report["route"] == "menudet-lazyudf" + np.testing.assert_array_equal(res, np.arange(100).reshape(shape)) assert res.shape == shape @@ -336,6 +336,7 @@ def test_kernel_index_float_cast_matches_ramp(): np.testing.assert_allclose(res, expected, rtol=0.0, atol=0.0) +@native_portable def test_kernel_index_float_cast_fast_path(monkeypatch): original_set_pref_expr = blosc2.NDArray._set_pref_expr captured = {"calls": 0, "expr": None} @@ -354,11 +355,8 @@ def wrapped_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None, expected = np.arange(np.prod(shape), dtype=np.float32).reshape(shape) np.testing.assert_allclose(res, expected, rtol=0.0, atol=0.0) - assert captured["calls"] >= 1 - assert "def kernel_index_ramp_float_cast(x):" in captured["expr"] - assert "float(_i0)" in captured["expr"] - assert "_n1" in captured["expr"] - assert "_i1" in captured["expr"] + assert captured["calls"] == 0 + assert expr._native_execution_report["route"] == "menudet-lazyudf" # ...and it JIT-compiles rather than silently running on the interpreter. _expect_jit( blosc2.validate_dsl_jit(kernel_index_ramp_float_cast, {"x": np.float32}, np.float32, shape=shape) @@ -454,6 +452,7 @@ def test_dsl_kernel_accepts_scalar_param_per_call(): np.testing.assert_allclose(res[...], expected, rtol=1e-5, atol=1e-6) +@native_portable def test_kernel_scalar_param_keeps_fast_path(monkeypatch): import importlib @@ -484,14 +483,8 @@ def wrapped_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None, expected = kernel_loop_param.func(a, b, niter) np.testing.assert_allclose(res[...], expected, rtol=1e-5, atol=1e-6) - assert captured["calls"] >= 1 - assert captured["keys"] == ("x", "y") - assert "def kernel_loop_param(x, y):" in captured["expr"] - assert "for it in range(3):" not in captured["expr"] - assert "for _i in range(3):" in captured["expr"] - assert "# loop count comes from scalar niter" in captured["expr"] - assert "range(niter)" not in captured["expr"] - assert "float(niter)" not in captured["expr"] + assert captured["calls"] == 0 + assert expr._native_execution_report["route"] == "menudet-lazyudf" # ...and the loop+scalar kernel JIT-compiles (the original G3 fallback shape). _expect_jit( blosc2.validate_dsl_jit( @@ -502,6 +495,7 @@ def wrapped_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None, lazyexpr_mod.try_miniexpr = old_try_miniexpr +@native_portable def test_kernel_scalar_float_cast_inlined(monkeypatch): import importlib @@ -528,15 +522,13 @@ def wrapped_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None, expected = kernel_scalar_float_cast.func(a, niter) np.testing.assert_allclose(res[...], expected, rtol=1e-5, atol=1e-6) - assert captured["calls"] >= 1 - assert captured["keys"] == ("x",) - assert "def kernel_scalar_float_cast(x):" in captured["expr"] - assert "offset = 3.0" in captured["expr"] - assert "float(3)" not in captured["expr"] + assert captured["calls"] == 0 + assert expr._native_execution_report["route"] == "menudet-lazyudf" finally: lazyexpr_mod.try_miniexpr = old_try_miniexpr +@native_portable def test_kernel_scalar_only_via_fast_eval(monkeypatch): import importlib @@ -563,14 +555,15 @@ def fail_slices_eval(*args, **kwargs): expr = blosc2.lazyudf(kernel_scalar_only, (3,), dtype=np.float32, shape=shape) res = expr.compute() - assert captured["fast_calls"] == 1 + assert captured["fast_calls"] == 0 assert captured["slices_calls"] == 0 - assert captured["operands"] == {"start": 3} - np.testing.assert_equal(res[...], np.zeros(shape, dtype=np.float32)) + assert captured["operands"] is None + np.testing.assert_equal(res[...], np.full(shape, 4, dtype=np.float32)) -def test_kernel_scalar_only_injects_dummy(monkeypatch): - """Scalar-only inputs specialize to a kernel with a dummy operand injected.""" +@native_portable +def test_kernel_scalar_only_needs_no_dummy(monkeypatch): + """Portable scalar-only recipes need no dummy input or legacy compiler.""" import importlib lazyexpr_mod = importlib.import_module("blosc2.lazyexpr") @@ -590,14 +583,8 @@ def failing_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None, try: shape = (8, 8) expr = blosc2.lazyudf(kernel_scalar_only, (3,), dtype=np.float32, shape=shape) - with pytest.raises( - RuntimeError, match="miniexpr compilation or execution failed for this DSL kernel" - ): - expr.compute() - assert captured["calls"] >= 1 - assert captured["keys"] == ("__me_dummy0",) - assert "def kernel_scalar_only(__me_dummy0):" in captured["expr"] - assert "return 3 + 1" in captured["expr"] + np.testing.assert_array_equal(expr.compute()[:], np.full(shape, 4, dtype=np.float32)) + assert captured["calls"] == 0 finally: lazyexpr_mod.try_miniexpr = old_try_miniexpr @@ -711,6 +698,7 @@ def kernel_const_subexpr(x, start, step): assert "ok" in result.stdout +@native_portable def test_kernel_failure_raises_strict_off(monkeypatch): import importlib @@ -718,26 +706,23 @@ def test_kernel_failure_raises_strict_off(monkeypatch): old_try_miniexpr = lazyexpr_mod.try_miniexpr lazyexpr_mod.try_miniexpr = True - def failing_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None, jit=None): - raise ValueError("forced miniexpr failure") + def failing_export(*args, **kwargs): + raise blosc2.PortableArtifactError("forced miniexpr failure", status="invalid_source") - monkeypatch.setattr(blosc2.NDArray, "_set_pref_expr", failing_set_pref_expr) + monkeypatch.setattr(blosc2.DSLKernel, "export", failing_export) try: _, _, a2, b2 = _make_arrays(shape=(32, 32), chunks=(16, 16), blocks=(8, 8)) expr = blosc2.lazyudf(kernel_loop, (a2, b2), dtype=a2.dtype) - with pytest.raises( - RuntimeError, match="miniexpr compilation or execution failed for this DSL kernel" - ): + with pytest.raises(RuntimeError, match="Menudet compilation failed for DSL kernel"): _ = expr.compute() - with pytest.raises( - RuntimeError, match="miniexpr compilation or execution failed for this DSL kernel" - ): + with pytest.raises(RuntimeError, match="Menudet compilation failed for DSL kernel"): _ = expr.compute(strict_miniexpr=False) finally: lazyexpr_mod.try_miniexpr = old_try_miniexpr +@native_portable def test_kernel_failure_includes_backend_error(monkeypatch): import importlib @@ -745,24 +730,25 @@ def test_kernel_failure_includes_backend_error(monkeypatch): old_try_miniexpr = lazyexpr_mod.try_miniexpr lazyexpr_mod.try_miniexpr = True - def failing_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None, jit=None): - raise ValueError("forced miniexpr backend failure details") + def failing_export(*args, **kwargs): + raise blosc2.PortableArtifactError( + "forced miniexpr backend failure details", status="invalid_source" + ) - monkeypatch.setattr(blosc2.NDArray, "_set_pref_expr", failing_set_pref_expr) + monkeypatch.setattr(blosc2.DSLKernel, "export", failing_export) try: _, _, a2, b2 = _make_arrays(shape=(32, 32), chunks=(16, 16), blocks=(8, 8)) expr = blosc2.lazyudf(kernel_loop, (a2, b2), dtype=a2.dtype) - with pytest.raises( - RuntimeError, match="miniexpr compilation or execution failed for this DSL kernel" - ) as excinfo: + with pytest.raises(RuntimeError, match="Menudet compilation failed for DSL kernel") as excinfo: _ = expr.compute() msg = str(excinfo.value) - assert "Backend error: forced miniexpr backend failure details" in msg + assert "forced miniexpr backend failure details" in msg finally: lazyexpr_mod.try_miniexpr = old_try_miniexpr +@native_portable def test_kernel_failure_prefers_validate_error(monkeypatch): import importlib @@ -770,8 +756,10 @@ def test_kernel_failure_prefers_validate_error(monkeypatch): old_try_miniexpr = lazyexpr_mod.try_miniexpr lazyexpr_mod.try_miniexpr = True - def failing_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None, jit=None): - raise ValueError("forced backend failure hidden by validate_dsl message") + def failing_export(*args, **kwargs): + raise blosc2.PortableArtifactError( + "forced backend failure hidden by validate_dsl message", status="invalid_source" + ) def fake_validate_dsl(_func): return { @@ -781,23 +769,22 @@ def fake_validate_dsl(_func): "error": "synthetic validate_dsl diagnostics", } - monkeypatch.setattr(blosc2.NDArray, "_set_pref_expr", failing_set_pref_expr) + monkeypatch.setattr(blosc2.DSLKernel, "export", failing_export) monkeypatch.setattr(lazyexpr_mod, "validate_dsl", fake_validate_dsl, raising=False) try: _, _, a2, b2 = _make_arrays(shape=(32, 32), chunks=(16, 16), blocks=(8, 8)) expr = blosc2.lazyudf(kernel_loop, (a2, b2), dtype=a2.dtype) - with pytest.raises( - RuntimeError, match="miniexpr compilation or execution failed for this DSL kernel" - ) as excinfo: + with pytest.raises(RuntimeError, match="Menudet compilation failed for DSL kernel") as excinfo: _ = expr.compute() msg = str(excinfo.value) - assert "Backend error: forced backend failure hidden by validate_dsl message" in msg + assert "forced backend failure hidden by validate_dsl message" in msg assert "synthetic validate_dsl diagnostics" not in msg finally: lazyexpr_mod.try_miniexpr = old_try_miniexpr +@native_portable def test_lazyudf_jit_policy_forwarding(monkeypatch): import importlib @@ -805,22 +792,23 @@ def test_lazyudf_jit_policy_forwarding(monkeypatch): old_try_miniexpr = lazyexpr_mod.try_miniexpr lazyexpr_mod.try_miniexpr = True - original_set_pref_expr = blosc2.NDArray._set_pref_expr + original_from_json = blosc2.PortableKernel.from_json seen = [] - def wrapped_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None, jit=None): + def wrapped_from_json(artifact, *, jit=None): seen.append(jit) - return original_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc, jit=jit) + return original_from_json(artifact, jit=jit) - monkeypatch.setattr(blosc2.NDArray, "_set_pref_expr", wrapped_set_pref_expr) + monkeypatch.setattr(blosc2.PortableKernel, "from_json", wrapped_from_json) try: _, _, a2, b2 = _make_arrays(shape=(32, 32), chunks=(16, 16), blocks=(8, 8)) expr = blosc2.lazyudf(kernel_loop, (a2, b2), dtype=a2.dtype, jit=False) _ = expr.compute(strict_miniexpr=False) + assert seen[-1] is False + seen.clear() _ = expr.compute(jit=True, strict_miniexpr=False) - assert seen[0] is False - assert seen[1] is True + assert seen[-1] is True finally: lazyexpr_mod.try_miniexpr = old_try_miniexpr @@ -920,17 +908,18 @@ def kernel_save_loop(x, y): return acc -def _save_reload_compute(kernel, inputs_np, inputs_b2, dtype, urlpaths, extra_kwargs=None): - """Save a LazyUDF backed by *kernel*, reload it, and return (reloaded_expr, result).""" +def _save_compute(kernel, inputs_b2, dtype, urlpaths, extra_kwargs=None): + """New authoring persists a native recipe, not a reconstructed Python function.""" lazy = blosc2.lazyudf(kernel, inputs_b2, dtype=dtype, **(extra_kwargs or {})) lazy.save(urlpath=urlpaths["lazy"]) - reloaded = blosc2.open(urlpaths["lazy"], mode="r", deserialize="full") - return reloaded, reloaded.compute() + restored = blosc2.open(urlpaths["lazy"]) + assert restored.partitions == lazy.blocks + assert restored.kernel.schema_version == "1.0" + return restored, restored.compute() def test_dsl_save_simple(tmp_path): - """Simple quadratic kernel: dsl_source and DSLKernel type survive a round-trip.""" - from blosc2.dsl_kernel import DSLKernel + """A quadratic author saves and safely reloads as native portable code.""" shape = (16, 16) na = np.linspace(0, 1, np.prod(shape), dtype=np.float32).reshape(shape) @@ -939,20 +928,15 @@ def test_dsl_save_simple(tmp_path): b = blosc2.asarray(nb, urlpath=str(tmp_path / "b.b2nd"), mode="w") urlpaths = {"lazy": str(tmp_path / "lazy.b2nd")} - reloaded, result = _save_reload_compute(kernel_save_simple, (na, nb), (a, b), np.float64, urlpaths) - - assert isinstance(reloaded, blosc2.LazyUDF) - assert isinstance(reloaded.func, DSLKernel), "func must be a DSLKernel after reload" - assert reloaded.func.dsl_source is not None, "dsl_source must be preserved" - assert "kernel_save_simple" in reloaded.func.dsl_source + reloaded, result = _save_compute(kernel_save_simple, (a, b), np.float64, urlpaths) + assert isinstance(reloaded.kernel, blosc2.PortableKernel) expected = (na + nb) ** 2 # (x+y)^2 == x^2 + y^2 + 2xy np.testing.assert_allclose(result[...], expected, rtol=1e-5, atol=1e-6) def test_dsl_save_clamp(tmp_path): - """Kernel with a `where` call survives save/reload and produces correct values.""" - from blosc2.dsl_kernel import DSLKernel + """Normalized where authoring roundtrips through native persistence.""" shape = (20, 20) na = np.linspace(0, 1, np.prod(shape), dtype=np.float32).reshape(shape) @@ -961,18 +945,15 @@ def test_dsl_save_clamp(tmp_path): b = blosc2.asarray(nb, urlpath=str(tmp_path / "b.b2nd"), mode="w") urlpaths = {"lazy": str(tmp_path / "lazy.b2nd")} - reloaded, result = _save_reload_compute(kernel_save_clamp, (na, nb), (a, b), np.float64, urlpaths) - - assert isinstance(reloaded.func, DSLKernel) - assert reloaded.func.dsl_source is not None + reloaded, result = _save_compute(kernel_save_clamp, (a, b), np.float64, urlpaths) + assert isinstance(reloaded.kernel, blosc2.PortableKernel) expected = np.where(na + nb > 1.5, na + nb, 1.5) np.testing.assert_allclose(result[...], expected, rtol=1e-5, atol=1e-6) def test_dsl_save_loop(tmp_path): - """Kernel with a loop (full DSL function) survives save/reload.""" - from blosc2.dsl_kernel import DSLKernel + """A static loop author roundtrips through native persistence.""" shape = (12, 12) na = np.linspace(0, 1, np.prod(shape), dtype=np.float32).reshape(shape) @@ -981,19 +962,15 @@ def test_dsl_save_loop(tmp_path): b = blosc2.asarray(nb, urlpath=str(tmp_path / "b.b2nd"), mode="w") urlpaths = {"lazy": str(tmp_path / "lazy.b2nd")} - reloaded, result = _save_reload_compute(kernel_save_loop, (na, nb), (a, b), np.float64, urlpaths) - - assert isinstance(reloaded.func, DSLKernel) - assert reloaded.func.dsl_source is not None - assert "for i in range(3):" in reloaded.func.dsl_source + reloaded, result = _save_compute(kernel_save_loop, (a, b), np.float64, urlpaths) + assert isinstance(reloaded.kernel, blosc2.PortableKernel) expected = kernel_save_loop.func(na, nb) np.testing.assert_allclose(result[...], expected, rtol=1e-5, atol=1e-6) def test_dsl_save_getitem(tmp_path): - """Reloaded DSL kernel supports __getitem__ (sliced access), not just compute().""" - from blosc2.dsl_kernel import DSLKernel + """Reloaded native recipes retain sliced access.""" shape = (16, 16) na = np.linspace(0, 1, np.prod(shape), dtype=np.float32).reshape(shape) @@ -1003,16 +980,13 @@ def test_dsl_save_getitem(tmp_path): lazy = blosc2.lazyudf(kernel_save_simple, (a, b), dtype=np.float64) lazy.save(urlpath=str(tmp_path / "lazy.b2nd")) - reloaded = blosc2.open(str(tmp_path / "lazy.b2nd"), mode="r", deserialize="full") - - assert isinstance(reloaded.func, DSLKernel) + reloaded = blosc2.open(tmp_path / "lazy.b2nd") expected = (na + nb) ** 2 np.testing.assert_allclose(reloaded[()], expected, rtol=1e-5, atol=1e-6) def test_dsl_save_input_names_match(tmp_path): - """After reload, input_names in the DSLKernel match the original kernel.""" - from blosc2.dsl_kernel import DSLKernel + """Native recipes preserve named positional bindings.""" shape = (10, 10) na = np.linspace(0, 1, np.prod(shape), dtype=np.float32).reshape(shape) @@ -1022,11 +996,20 @@ def test_dsl_save_input_names_match(tmp_path): lazy = blosc2.lazyudf(kernel_save_simple, (a, b), dtype=np.float64) lazy.save(urlpath=str(tmp_path / "lazy.b2nd")) - reloaded = blosc2.open(str(tmp_path / "lazy.b2nd"), mode="r", deserialize="full") - - assert isinstance(reloaded.func, DSLKernel) - assert reloaded.func.input_names == ["x", "y"] - assert list(reloaded.inputs_dict.keys()) == ["x", "y"] + reloaded = blosc2.open(tmp_path / "lazy.b2nd") + assert list(reloaded.kernel.input_dtypes) == ["x", "y"] + assert list(reloaded.inputs) == ["x", "y"] + grouped = blosc2.asarray( + np.arange(8, dtype="int64"), chunks=(8,), blocks=(2,), urlpath=tmp_path / "grouped.b2nd", mode="w" + ) + kernel = blosc2.DSLKernel.from_source("def grouped(x):\n return x + block_sum(x) + _i0\n") + authored = blosc2.lazyudf(kernel, (grouped,), dtype="int64") + frame = authored.to_cframe() + restored = blosc2.from_cframe(frame) + expected = np.arange(8) * 2 + np.repeat(np.arange(8).reshape(4, 2).sum(axis=1), 2) + assert restored.partitions == (2,) + np.testing.assert_array_equal(restored[:], expected) + np.testing.assert_array_equal(restored[1:7:2], expected[1:7:2]) def test_dsl_save_dictstore_operands(tmp_path): @@ -1047,16 +1030,7 @@ def test_dsl_save_dictstore_operands(tmp_path): b = dstore["/b"] lazy = blosc2.lazyudf(kernel_save_simple, (a, b), dtype=np.float64) lazy.save(urlpath=str(expr_path)) - - carrier = blosc2.open(str(expr_path), mode="r", deserialize="full").array - assert carrier.schunk.vlmeta["b2o"]["operands"] == { - "o0": {"kind": "dictstore_key", "version": 1, "urlpath": "ops.b2z", "key": "/a"}, - "o1": {"kind": "dictstore_key", "version": 1, "urlpath": "ops.b2z", "key": "/b"}, - } - - reloaded = blosc2.open(str(expr_path), mode="r", deserialize="full") - expected = (np.arange(shape[0], dtype=np.float64) * 3) ** 2 - np.testing.assert_allclose(reloaded.compute()[...], expected, rtol=1e-5, atol=1e-6) + np.testing.assert_array_equal(blosc2.open(expr_path)[:], (np.arange(10) * 3) ** 2) # --- plans/dsl-glitches.md regressions: G1 (one-per-line), G2 (input reassign), @@ -1240,6 +1214,7 @@ def test_dsl_kernel_reassigning_input_param_rejected(): assert "input parameter 'a'" in result["error"] +@native_portable def test_dsl_kernel_variable_named_out_compiles(monkeypatch): # G3: 'out' collides with the codegen output pointer -> used to silently fall # back to the interpreter. miniexpr now namespaces its codegen identifiers @@ -1278,9 +1253,8 @@ def wrapped(self, expression, inputs, fp_accuracy, aux_reduc=None, jit=None): a2 = blosc2.asarray(a, chunks=(4, 4), blocks=(2, 2)) res = blosc2.lazyudf(k, (a2, a2, 32), dtype=np.float64, jit=True)[:] - # Bare 'out' was handed to miniexpr and the result matches the interpreter. - assert captured["expr"] is not None - assert any(line.strip().startswith("out =") for line in captured["expr"].splitlines()) + # Portable code generation handles the reserved local without legacy compilation. + assert captured["expr"] is None expected = blosc2.lazyudf(k, (a2, a2, 32), dtype=np.float64, jit=False)[:] np.testing.assert_allclose(res, expected) @@ -1398,11 +1372,12 @@ def test_kernel_numpy_f_ordered_and_strided(): np.testing.assert_array_equal(res_strided, ref_strided) -def test_kernel_non_native_endian_needs_miniexpr(): +@native_portable +def test_kernel_non_native_endian_portable_conversion(): a = np.arange(100, dtype=">f8").reshape(10, 10) b = np.arange(100, dtype=np.float64).reshape(10, 10) - with pytest.raises(RuntimeError, match="NDArray or NumPy inputs"): - blosc2.lazyudf(_numpy_operand_kernel, (a, b), dtype=None)[()] + result = blosc2.lazyudf(_numpy_operand_kernel, (a, b), dtype=None)[()] + np.testing.assert_array_equal(result, _dsl_reference(_numpy_operand_kernel, (a.astype("float64"), b))) def test_kernel_zero_input_dummy_injection(): diff --git a/tests/ndarray/test_elementwise_funcs.py b/tests/ndarray/test_elementwise_funcs.py index 91bb6655f..9c9f44ea9 100644 --- a/tests/ndarray/test_elementwise_funcs.py +++ b/tests/ndarray/test_elementwise_funcs.py @@ -5,7 +5,6 @@ # SPDX-License-Identifier: BSD-3-Clause ####################################################################### -import sys import warnings import numpy as np @@ -44,6 +43,17 @@ SHAPES_CHUNKS_HEAVY = [((10, 13, 13), (3, 5, 2))] +def _function_dtype_layout_cases(function_pairs): + # Dtype support is function-specific, so retain every function/dtype pair. + # Rank and chunk traversal are shared: rotate 1-D/2-D layouts instead of + # duplicating every pair. Each function and dtype still sees both ranks. + return [ + (np_func, blosc_func, dtype, *SHAPES_CHUNKS[(function_index + dtype_index) % len(SHAPES_CHUNKS)]) + for function_index, (np_func, blosc_func) in enumerate(function_pairs) + for dtype_index, dtype in enumerate(DTYPES) + ] + + def _test_unary_func_impl(np_func, blosc_func, dtype, shape, chunkshape): """Helper function containing the actual test logic for unary functions.""" if np_func.__name__ in ("arccos", "arcsin", "arctanh"): @@ -179,15 +189,6 @@ def _test_binary_func_proxy(np_func, blosc_func, dtype, shape, chunkshape, xp): dtype, "integral" ): # overflow causes disagreement, no problem assert True - elif np_func.__name__ in ("maximum", "minimum") and blosc2.isdtype(dtype, "real floating"): - warnings.showwarning( - "minimum and maximum for numexpr do not match NaN behaviour for numpy", - UserWarning, - __file__, - 0, - file=sys.stderr, - ) - pytest.skip("minimum and maximum for numexpr do not match NaN behaviour for numpy") else: raise @@ -294,22 +295,14 @@ def _test_binary_func_impl(np_func, blosc_func, dtype, shape, chunkshape): dtype, "integral" ): # overflow causes disagreement, no problem assert True - elif np_func.__name__ in ("maximum", "minimum") and blosc2.isdtype(dtype, "real floating"): - warnings.showwarning( - "minimum and maximum for numexpr do not match NaN behaviour for numpy", - UserWarning, - __file__, - 0, - file=sys.stderr, - ) - pytest.skip("minimum and maximum for numexpr do not match NaN behaviour for numpy") else: raise -@pytest.mark.parametrize(("np_func", "blosc_func"), UNARY_FUNC_PAIRS) -@pytest.mark.parametrize("dtype", DTYPES) -@pytest.mark.parametrize(("shape", "chunkshape"), SHAPES_CHUNKS) +@pytest.mark.parametrize( + ("np_func", "blosc_func", "dtype", "shape", "chunkshape"), + _function_dtype_layout_cases(UNARY_FUNC_PAIRS), +) def test_unary_funcs(np_func, blosc_func, dtype, shape, chunkshape): _test_unary_func_impl(np_func, blosc_func, dtype, shape, chunkshape) @@ -332,9 +325,10 @@ def test_unary_funcs_heavy(np_func, blosc_func, dtype, shape, chunkshape): _test_unary_func_impl(np_func, blosc_func, dtype, shape, chunkshape) -@pytest.mark.parametrize(("np_func", "blosc_func"), BINARY_FUNC_PAIRS) -@pytest.mark.parametrize("dtype", DTYPES) -@pytest.mark.parametrize(("shape", "chunkshape"), SHAPES_CHUNKS) +@pytest.mark.parametrize( + ("np_func", "blosc_func", "dtype", "shape", "chunkshape"), + _function_dtype_layout_cases(BINARY_FUNC_PAIRS), +) def test_binary_funcs(np_func, blosc_func, dtype, shape, chunkshape): _test_binary_func_impl(np_func, blosc_func, dtype, shape, chunkshape) diff --git a/tests/ndarray/test_expression_fusion_threads.py b/tests/ndarray/test_expression_fusion_threads.py new file mode 100644 index 000000000..92ecbe654 --- /dev/null +++ b/tests/ndarray/test_expression_fusion_threads.py @@ -0,0 +1,41 @@ +"""Expression fusion must not disable comparisons in another thread.""" + +import importlib +from concurrent.futures import ThreadPoolExecutor +from threading import Event, get_ident + +import numpy as np +import pytest + +import blosc2 + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Pyodide does not support Python threads") +def test_fusion_keeps_elementwise_equality_in_other_threads(monkeypatch): + module = importlib.import_module("blosc2.lazyexpr") + arr = blosc2.asarray(np.arange(4)) + expr = arr + 1 + entered, release = Event(), Event() + original = module.check_dtype + main_thread = get_ident() + + def paused_check_dtype(*args, **kwargs): + if get_ident() != main_thread: + entered.set() + assert release.wait(10), "Comparison thread did not release fusion" + return original(*args, **kwargs) + + monkeypatch.setattr(module, "check_dtype", paused_check_dtype) + with ThreadPoolExecutor(max_workers=1) as pool: + future = pool.submit(lambda: expr + arr) + try: + assert entered.wait(10), "Fusion did not reach dtype checking" + assert not blosc2._disable_overloaded_equal + comparison = arr == 2 + assert isinstance(comparison, blosc2.LazyExpr) + finally: + release.set() + fused = future.result(timeout=10) + assert not blosc2._disable_overloaded_equal + np.testing.assert_array_equal(comparison[:], np.arange(4) == 2) + np.testing.assert_array_equal(fused[:], np.arange(4) * 2 + 1) diff --git a/tests/ndarray/test_jit_dsl_dispatch.py b/tests/ndarray/test_jit_dsl_dispatch.py index e18b3a6ca..135188cce 100644 --- a/tests/ndarray/test_jit_dsl_dispatch.py +++ b/tests/ndarray/test_jit_dsl_dispatch.py @@ -53,9 +53,9 @@ def mandel(cr, ci, max_iter): monkeypatch.setenv("BLOSC_ME_JIT_TRACE", "1") res = mandel(cr, ci, 30) captured = capsys.readouterr() - # Under WebAssembly this kernel is transpiled to the JS bridge instead of - # going through miniexpr (see _maybe_js_backend); both engines trace. - assert f"engine={'js' if blosc2.IS_WASM else 'miniexpr'}" in captured.out + # The control-flow route uses Menudet on native hosts and on wasm32, where + # dispatch pins interpretation instead of selecting the JS transpiler. + assert "engine=menudet" in captured.out assert "def mandel" in captured.out np.testing.assert_array_equal(res, _mandel_numpy(cr, ci, 30)) diff --git a/tests/ndarray/test_jit_options.py b/tests/ndarray/test_jit_options.py index dda096266..4fbe328ac 100644 --- a/tests/ndarray/test_jit_options.py +++ b/tests/ndarray/test_jit_options.py @@ -294,7 +294,7 @@ def test_evaluation_time_and_udf_policy(capfd): np.testing.assert_array_equal(expr.compute()[:], np.arange(32) + 1) assert "jit runtime built:" in capfd.readouterr().err np.testing.assert_array_equal(udf[:], np.arange(32) * 2 + 1) - assert "reason=jit_mode=off" in capfd.readouterr().err + assert "request=2" in capfd.readouterr().err assert blosc2.get_jit_options()["trace"] is False @@ -353,6 +353,53 @@ def test_environment_overrides_and_tcc_ignores_cc_settings(tmp_path, capfd, monk assert capfd.readouterr() == ("", "") +@pytest.mark.parametrize("backend", ["tcc", "cc"]) +def test_synthesized_backend_respects_environment_and_source(monkeypatch, backend): + from blosc2.lazyexpr import _apply_jit_backend_pragma + + monkeypatch.setenv("ME_DSL_JIT_COMPILER", backend) + other = "cc" if backend == "tcc" else "tcc" + inputs = {"x": np.arange(4, dtype=np.float64)} + assert _apply_jit_backend_pragma("x + 1", inputs, other).startswith(f"# me:compiler={backend}\n") + source = f"# me:compiler={other}\ndef k(x):\n return x + 1\n" + assert _apply_jit_backend_pragma(source, inputs, backend) == source + commented = "# me:fp=strict\ndef k(x):\n return x\n" + assert _apply_jit_backend_pragma(commented, inputs, other) == f"# me:compiler={backend}\n{commented}" + + +@pytest.mark.parametrize("backend", ["tcc", "cc"]) +@pytest.mark.parametrize("jit", [False, True]) +def test_reduction_backend_preserves_scalar_accumulator(monkeypatch, backend, jit): + import importlib + + lazyexpr = importlib.import_module("blosc2.lazyexpr") + + def reject_elementwise_wrapper(*args): + pytest.fail("Scalar reductions must not be wrapped in elementwise DSL source") + + monkeypatch.setattr(lazyexpr, "_apply_jit_backend_pragma", reject_elementwise_wrapper) + original = blosc2.NDArray._set_pref_expr + calls = [] + + def capture(self, expression, inputs, fp_accuracy, aux_reduc=None, **kwargs): + assert aux_reduc is not None + assert kwargs["jit"] is False # Prevent native auto-lifting as well. + calls.append(expression) + return original(self, expression, inputs, fp_accuracy, aux_reduc, **kwargs) + + monkeypatch.setattr(blosc2.NDArray, "_set_pref_expr", capture) + values = np.arange(128, dtype=np.float64) + expr = blosc2.asarray(values) * 2 + 1 + assert expr.sum(jit=jit, jit_backend=backend) == (values * 2 + 1).sum() + if blosc2.IS_WASM: + # WASM currently uses the non-prefilter reduction path. It must still + # produce correct results without introducing an elementwise wrapper. + assert not calls + else: + assert calls + assert all(expression.startswith("sum(") for expression in calls) + + @pytest.mark.skipif(blosc2.IS_WASM or os.name == "nt", reason="POSIX compiler-output injection") def test_compiler_output(tmp_path, capfd): compiler = tmp_path / "bad cc's executable" @@ -372,7 +419,7 @@ def test_compiler_output(tmp_path, capfd): ("variable", "value", "reason"), [ ("CC", "/no/env/compiler", "c compiler unavailable"), - ("CFLAGS", "-invalid-blosc2-option", "compilation failed"), + ("CFLAGS", "-invalid-blosc2-option", "explicit compiler flags"), ], ) def test_cc_environment_precedence(tmp_path, capfd, monkeypatch, variable, value, reason): @@ -383,5 +430,5 @@ def test_cc_environment_precedence(tmp_path, capfd, monkeypatch, variable, value ): blosc2.linspace(0, 11, 79) assert reason in capfd.readouterr().err - assert (tmp_path / "env-cache").exists() + assert (tmp_path / "env-cache").exists() == (variable == "CC") assert not (tmp_path / "python-cache").exists() diff --git a/tests/ndarray/test_lazyexpr.py b/tests/ndarray/test_lazyexpr.py index 5a099cbac..4be24af5d 100644 --- a/tests/ndarray/test_lazyexpr.py +++ b/tests/ndarray/test_lazyexpr.py @@ -87,21 +87,32 @@ def shape_fixture(request): return request.param -# params: (same_chunks, same_blocks) +# Keep both precisions at every size/rank, rotating the partition relationship +# instead of multiplying it across every case. The full grid remains opt-in. +DEFAULT_ARRAY_SCENARIOS = { + (np.float32, (NITEMS_SMALL,), (True, True)), + (np.float32, (NITEMS,), (True, False)), + (np.float32, (NITEMS // 10, 100), (True, True)), + (np.float64, (NITEMS_SMALL,), (True, False)), + (np.float64, (NITEMS,), (True, True)), + (np.float64, (NITEMS // 10, 100), (True, False)), +} + + @pytest.fixture( params=[ - (True, True), - (True, False), - pytest.param((False, True), marks=pytest.mark.heavy), - pytest.param((False, False), marks=pytest.mark.heavy), + pytest.param( + (dtype, shape, partitions), + marks=[] if (dtype, shape, partitions) in DEFAULT_ARRAY_SCENARIOS else pytest.mark.heavy, + id=f"{np.dtype(dtype).name}-{shape}-{partitions}", + ) + for dtype in (np.float32, np.float64) + for shape in ((NITEMS_SMALL,), (NITEMS,), (NITEMS // 10, 100)) + for partitions in ((True, True), (True, False), (False, True), (False, False)) ] ) -def chunks_blocks_fixture(request): - return request.param - - -@pytest.fixture -def array_fixture(dtype_fixture, shape_fixture, chunks_blocks_fixture): +def array_fixture(request): + dtype_fixture, shape_fixture, chunks_blocks_fixture = request.param nelems = np.prod(shape_fixture) na1 = np.linspace(0, 10, nelems, dtype=dtype_fixture).reshape(shape_fixture) chunks = chunks1 = blocks = blocks1 = None # silence linter @@ -317,6 +328,21 @@ def test_complex_evaluate(array_fixture): np.testing.assert_allclose(res[:], nres) +@pytest.mark.parametrize("dtype", ["complex64", "complex128"]) +def test_complex_multiply_infinity(dtype): + values = np.array([complex(np.inf, -np.inf), complex(np.inf, 1), 1 + 2j, 0j], dtype=dtype) + array = blosc2.asarray(values, chunks=(4,), blocks=(2,)) + with np.errstate(invalid="ignore"): + expected = values * 2 + 1 + expr = array * 2 + 1 + results = [expr[:], expr[::2], expr.compute(jit=False)[:]] + for actual, reference in zip(results, [expected, expected[::2], expected], strict=True): + # Compare components separately: complex NaN equality can hide an + # incorrect finite/infinite component when its other component is NaN. + np.testing.assert_equal(actual.real, reference.real) + np.testing.assert_equal(actual.imag, reference.imag) + + def test_complex_getitem(array_fixture): a1, a2, a3, a4, na1, na2, na3, na4 = array_fixture expr = blosc2.tan(a1) * (blosc2.sin(a2) * blosc2.sin(a2) + blosc2.cos(a3)) + (blosc2.sqrt(a4) * 2) @@ -487,7 +513,7 @@ def test_arctan2_pow(urlpath, shape_fixture, dtype_fixture, function, value1, va expr = blosc2.LazyExpr(new_op=(a1, function, a2)) if urlpath is not None: expr.save(urlpath=urlpath_save) - expr = blosc2.open(urlpath_save, mode="r", deserialize="full") + expr = blosc2.open(urlpath_save, mode="r") res_lazyexpr = expr.compute() # Evaluate using NumExpr if function == "**": @@ -501,7 +527,7 @@ def test_arctan2_pow(urlpath, shape_fixture, dtype_fixture, function, value1, va expr = blosc2.LazyExpr(new_op=(a1, function, value2)) if urlpath is not None: expr.save(urlpath=urlpath_save) - expr = blosc2.open(urlpath_save, mode="r", deserialize="full") + expr = blosc2.open(urlpath_save, mode="r") res_lazyexpr = expr.compute() # Evaluate using NumExpr if function == "**": @@ -517,7 +543,7 @@ def test_arctan2_pow(urlpath, shape_fixture, dtype_fixture, function, value1, va expr = blosc2.LazyExpr(new_op=(value1, function, a2)) if urlpath is not None: expr.save(urlpath=urlpath_save) - expr = blosc2.open(urlpath_save, mode="r", deserialize="full") + expr = blosc2.open(urlpath_save, mode="r") res_lazyexpr = expr.compute() # Evaluate using NumExpr if function == "**": @@ -737,7 +763,7 @@ def test_save(): ) np.testing.assert_allclose(res[:], nres, rtol=tol, atol=tol) - expr = blosc2.open(urlpath_save, mode="r", deserialize="full") + expr = blosc2.open(urlpath_save, mode="r") # After opening, check that a lazy expression does have an array # and schunk attributes. This is to allow the .info() method to work. assert hasattr(expr, "array") is True @@ -755,11 +781,12 @@ def test_save(): expr = "a1 / a2 + a2 - a3 * a4**x" var_dict = {"a1": ops[0], "a2": ops[1], "a3": ops[2], "a4": ops[3], "x": x} lazy_expr = eval(expr, var_dict) + expected_persisted = lazy_expr[:] lazy_expr.save(urlpath=urlpath_save2) - expr = blosc2.open(urlpath_save2, mode="r", deserialize="full") + expr = blosc2.open(urlpath_save2, mode="r") assert expr.array.dtype == np.float64 res = expr.compute() - nres = ne_evaluate("na1 / na2 + na2 - na3 * na4**3") + nres = expected_persisted # Persistence must preserve values, not another engine's pow lowering. np.testing.assert_allclose(res[:], nres, rtol=tol, atol=tol) # Test getitem np.testing.assert_allclose(expr[:], nres, rtol=tol, atol=tol) @@ -780,7 +807,7 @@ def test_save_unsafe(): expr.save(urlpath=urlpath) disk_arrays.append(urlpath) - expr = blosc2.open(urlpath, mode="r", deserialize="full") + expr = blosc2.open(urlpath, mode="r") # Replace expression by a (potentially) unsafe expression expr.expression = "import os; os.system('touch /tmp/unsafe')" with pytest.raises(ValueError) as excinfo: @@ -828,7 +855,7 @@ def test_save_functions(function, dtype_fixture, shape_fixture): expr = blosc2.LazyExpr(new_op=(a1, function, None)) expr.save(urlpath=urlpath_save) del expr - expr = blosc2.open(urlpath_save, mode="r", deserialize="full") + expr = blosc2.open(urlpath_save, mode="r") res_lazyexpr = expr.compute() # Evaluate using NumExpr @@ -844,7 +871,7 @@ def test_save_functions(function, dtype_fixture, shape_fixture): res_lazyexpr = expr.compute() np.testing.assert_allclose(res_lazyexpr[:], res_numexpr, rtol=rtol) - expr = blosc2.open(urlpath_save, mode="r", deserialize="full") + expr = blosc2.open(urlpath_save, mode="r") res_lazyexpr = expr.compute() np.testing.assert_allclose(res_lazyexpr[:], res_numexpr, rtol=rtol) @@ -868,7 +895,7 @@ def test_save_contains(values): # Construct the lazy expression expr_lazy = blosc2.LazyExpr(new_op=(a1_blosc, "contains", value2)) expr_lazy.save(urlpath=urlpath_save) - expr_lazy = blosc2.open(urlpath_save, mode="r", deserialize="full") + expr_lazy = blosc2.open(urlpath_save, mode="r") # Evaluate using NumExpr expr_numexpr = f"{'contains'}(a1, value2)" res_numexpr = ne_evaluate(expr_numexpr) @@ -878,7 +905,7 @@ def test_save_contains(values): # Construct the lazy expression expr_lazy = blosc2.LazyExpr(new_op=(a1_blosc, "contains", a2_blosc)) expr_lazy.save(urlpath=urlpath_save) - expr_lazy = blosc2.open(urlpath_save, mode="r", deserialize="full") + expr_lazy = blosc2.open(urlpath_save, mode="r") # Evaluate using NumExpr res_numexpr = ne_evaluate("contains(a2, a1)") else: # ("str", "NDArray") @@ -888,7 +915,7 @@ def test_save_contains(values): # Construct the lazy expression expr_lazy = blosc2.LazyExpr(new_op=(value1, "contains", a2_blosc)) expr_lazy.save(urlpath=urlpath_save) - expr_lazy = blosc2.open(urlpath_save, mode="r", deserialize="full") + expr_lazy = blosc2.open(urlpath_save, mode="r") # Evaluate using NumExpr res_numexpr = ne_evaluate("contains(value1, a2)") res_lazyexpr = expr_lazy.compute() @@ -922,7 +949,7 @@ def test_save_many_functions(dtype_fixture, shape_fixture): res_lazyexpr = expr.compute() np.testing.assert_allclose(res_lazyexpr[:], res_numexpr, rtol=rtol, atol=atol) - expr = blosc2.open(urlpath_save, mode="r", deserialize="full") + expr = blosc2.open(urlpath_save, mode="r") res_lazyexpr = expr.compute() np.testing.assert_allclose(res_lazyexpr[:], res_numexpr, rtol=rtol, atol=atol) @@ -976,7 +1003,7 @@ def test_save_constructor(disk, shape, dtype, constructor): a = b2func(lshape, dtype=dtype, shape=shape, urlpath=urlpath, mode="w") expr = f"a + {constructor}({lshape}, dtype={dtype}, shape={shape}) + 1" if disk: - a = blosc2.open(urlpath, mode="r", deserialize="full") + a = blosc2.open(urlpath, mode="r") npfunc = getattr(np, constructor) if constructor == "linspace": na = npfunc(0, 10, lshape, dtype=dtype).reshape(shape) @@ -994,7 +1021,7 @@ def test_save_constructor(disk, shape, dtype, constructor): assert lexpr.shape == a.shape if disk: lexpr.save("out.b2nd") - lexpr = blosc2.open("out.b2nd", mode="r", deserialize="full") + lexpr = blosc2.open("out.b2nd", mode="r") res = lexpr.compute() nres = na + na + 1 assert np.allclose(res[()], nres) @@ -1016,7 +1043,7 @@ def test_save_2_constructors(shape, disk): lexpr = blosc2.lazyexpr(expr) if disk: lexpr.save("out.b2nd") - lexpr = blosc2.open("out.b2nd", mode="r", deserialize="full") + lexpr = blosc2.open("out.b2nd", mode="r") res = lexpr.compute() na = np.arange(lshape).reshape(shape) nb = np.ones(shape) @@ -1043,7 +1070,7 @@ def test_save_constructor_reshape(shape, disk): lexpr = blosc2.lazyexpr(expr) if disk: lexpr.save("out.b2nd") - lexpr = blosc2.open("out.b2nd", mode="r", deserialize="full") + lexpr = blosc2.open("out.b2nd", mode="r") res = lexpr.compute() na = np.arange(lshape).reshape(shape) nb = np.ones(shape) @@ -1067,7 +1094,7 @@ def test_save_2equal_constructors(shape, disk): lexpr = blosc2.lazyexpr(expr) if disk: lexpr.save("out.b2nd") - lexpr = blosc2.open("out.b2nd", mode="r", deserialize="full") + lexpr = blosc2.open("out.b2nd", mode="r") res = lexpr.compute() na = np.ones(shape, dtype=np.int8) nb = np.ones(shape) @@ -1374,9 +1401,9 @@ def test_fill_disk_operands(chunks, blocks, disk, fill_value): b = blosc2.zeros((N, N), urlpath=bpath, mode="w", chunks=chunks, blocks=blocks) c = blosc2.zeros((N, N), urlpath=cpath, mode="w", chunks=chunks, blocks=blocks) if disk: - a = blosc2.open("a.b2nd", mode="r", deserialize="full") - b = blosc2.open("b.b2nd", mode="r", deserialize="full") - c = blosc2.open("c.b2nd", mode="r", deserialize="full") + a = blosc2.open("a.b2nd", mode="r") + b = blosc2.open("b.b2nd", mode="r") + c = blosc2.open("c.b2nd", mode="r") expr = ((a**3 + blosc2.sin(c * 2)) < b) & ~(c > 0) @@ -1720,7 +1747,7 @@ def test_missing_operator(): blosc2.remove_urlpath("b.b2nd") # Re-open the lazy expression with pytest.raises(blosc2.exceptions.MissingOperands) as excinfo: - blosc2.open("expr.b2nd", mode="r", deserialize="full") + blosc2.open("expr.b2nd", mode="r") # Check that some operand is missing assert "a" not in excinfo.value.missing_ops @@ -1751,13 +1778,13 @@ def test_save_dictstore_operands(tmp_path): expr = blosc2.lazyexpr("a + b") expr.save(expr_path) - carrier = blosc2.open(expr_path, mode="r", deserialize="full").array + carrier = blosc2.open(expr_path, mode="r").array assert carrier.schunk.vlmeta["b2o"]["operands"] == { "a": {"kind": "dictstore_key", "version": 1, "urlpath": str(store_path), "key": "/a"}, "b": {"kind": "dictstore_key", "version": 1, "urlpath": str(store_path), "key": "/b"}, } - restored = blosc2.open(expr_path, mode="r", deserialize="full") + restored = blosc2.open(expr_path, mode="r") assert isinstance(restored, blosc2.LazyExpr) np.testing.assert_array_equal(restored[:], expected) @@ -1773,6 +1800,9 @@ def test_save_proxy_operands_reopen_default_mode(tmp_path): expr = proxy + proxy expr.save(str(expr_path)) + # Proxy reconstruction remains full-only, even inside an ordinary expression. + with pytest.raises(blosc2.UnsafeDeserializationError, match="proxy"): + blosc2.open(str(expr_path), mode="r") restored = blosc2.open(str(expr_path), mode="r", deserialize="full") assert isinstance(restored, blosc2.LazyExpr) @@ -1795,7 +1825,7 @@ def test_lazyexpr_vlmeta_in_memory_and_persisted(tmp_path): expr_path = tmp_path / "expr_vlmeta.b2nd" expr.save(str(expr_path)) - restored = blosc2.open(str(expr_path), mode="r", deserialize="full") + restored = blosc2.open(str(expr_path), mode="r") assert restored.vlmeta["name"] == "sum" assert restored.vlmeta["config"] == {"scale": 1} @@ -1803,9 +1833,9 @@ def test_lazyexpr_vlmeta_in_memory_and_persisted(tmp_path): with pytest.raises(ValueError, match="reading mode"): restored.vlmeta["note"] = "persisted" - writable = blosc2.open(str(expr_path), mode="a", deserialize="full") + writable = blosc2.open(str(expr_path), mode="a") writable.vlmeta["note"] = "persisted" - reopened = blosc2.open(str(expr_path), mode="r", deserialize="full") + reopened = blosc2.open(str(expr_path), mode="r") assert reopened.vlmeta["note"] == "persisted" np.testing.assert_array_equal(reopened[:], np.arange(5, dtype=np.int64) * 2) @@ -1881,19 +1911,19 @@ def test_chain_persistentexpressions(): le1_ = blosc2.lazyexpr("a ** 3 + sin(a ** 2)", {"a": a}) le1_.save("expr1.b2nd", mode="w") - myle1 = blosc2.open("expr1.b2nd", mode="r", deserialize="full") + myle1 = blosc2.open("expr1.b2nd", mode="r") le2_ = blosc2.lazyexpr("(le1 < c)", {"le1": myle1, "c": c}) le2_.save("expr2.b2nd", mode="w") - myle2 = blosc2.open("expr2.b2nd", mode="r", deserialize="full") + myle2 = blosc2.open("expr2.b2nd", mode="r") le3_ = blosc2.lazyexpr("(b < 0)", {"b": b}) le3_.save("expr3.b2nd", mode="w") - myle3 = blosc2.open("expr3.b2nd", mode="r", deserialize="full") + myle3 = blosc2.open("expr3.b2nd", mode="r") le4_ = blosc2.lazyexpr("(le2 & le3)", {"le2": myle2, "le3": myle3}) le4_.save("expr4.b2nd", mode="w") - myle4 = blosc2.open("expr4.b2nd", mode="r", deserialize="full") + myle4 = blosc2.open("expr4.b2nd", mode="r") assert (myle4[:] == le4[:]).all() # Remove files @@ -2403,6 +2433,6 @@ def test_cumulative_block_layout(monkeypatch, blocks): out = blosc2.empty(data.shape, dtype=data.dtype, chunks=chunks, blocks=blocks) expression = a + 0 result = expression.cumulative_sum(axis=0, out=out) - expected = np.cumulative_sum(data, axis=0) + expected = np.cumsum(data, axis=0) np.testing.assert_array_equal(result[:], expected) np.testing.assert_array_equal(out[:], expected) diff --git a/tests/ndarray/test_lazyexpr_fields.py b/tests/ndarray/test_lazyexpr_fields.py index 4fa5af2ff..643af6a2e 100644 --- a/tests/ndarray/test_lazyexpr_fields.py +++ b/tests/ndarray/test_lazyexpr_fields.py @@ -15,53 +15,57 @@ NITEMS = 1000 -@pytest.fixture( - params=[ - (np.float32, np.float64), - pytest.param((np.float64, np.float64), marks=pytest.mark.heavy), - (np.int32, np.float32), - (np.int32, np.uint32), - pytest.param( - (np.int8, np.int16), - marks=pytest.mark.skipif( - np.__version__.startswith("1."), reason="NumPy < 2.0 has different casting rules" - ), - ), - # The next dtypes work, but running everything takes too much time - pytest.param((np.int32, np.float64), marks=pytest.mark.heavy), - pytest.param((np.int8, np.float64), marks=pytest.mark.heavy), - pytest.param((np.uint8, np.uint16), marks=pytest.mark.heavy), - pytest.param((np.uint8, np.uint32), marks=pytest.mark.heavy), - pytest.param((np.uint8, np.float32), marks=pytest.mark.heavy), - pytest.param((np.uint16, np.float64), marks=pytest.mark.heavy), - ] -) -def dtype_fixture(request): - return request.param +FIELD_DTYPE_PAIRS = [ + (np.float32, np.float64), + (np.float64, np.float64), + (np.int32, np.float32), + (np.int32, np.uint32), + (np.int8, np.int16), + (np.int32, np.float64), + (np.int8, np.float64), + (np.uint8, np.uint16), + (np.uint8, np.uint32), + (np.uint8, np.float32), + (np.uint16, np.float64), +] + +# Preserve every default mixed-dtype pair with both partition relationships and +# both sizes; rotate their combinations. All other original cases stay heavy. +DEFAULT_ARRAY_SCENARIOS = { + ((np.float32, np.float64), (NITEMS_SMALL,), (True, True)), + ((np.float32, np.float64), (NITEMS,), (True, False)), + ((np.int32, np.float32), (NITEMS_SMALL,), (True, False)), + ((np.int32, np.float32), (NITEMS,), (True, True)), + ((np.int32, np.uint32), (NITEMS_SMALL,), (True, True)), + ((np.int32, np.uint32), (NITEMS,), (True, False)), + ((np.int8, np.int16), (NITEMS_SMALL,), (True, False)), + ((np.int8, np.int16), (NITEMS,), (True, True)), +} -@pytest.fixture( - params=[(NITEMS_SMALL,), (NITEMS,), pytest.param((NITEMS // 10, 100), marks=pytest.mark.heavy)] -) -def shape_fixture(request): - return request.param - - -# params: (same_chunks, same_blocks) @pytest.fixture( params=[ - (True, True), - (True, False), - pytest.param((False, True), marks=pytest.mark.heavy), - pytest.param((False, False), marks=pytest.mark.heavy), + pytest.param( + (dtypes, shape, partitions), + marks=([] if (dtypes, shape, partitions) in DEFAULT_ARRAY_SCENARIOS else [pytest.mark.heavy]) + + ( + [ + pytest.mark.skipif( + np.__version__.startswith("1."), reason="NumPy < 2.0 has different casting rules" + ) + ] + if dtypes == (np.int8, np.int16) + else [] + ), + id=f"{np.dtype(dtypes[0]).name}-{np.dtype(dtypes[1]).name}-{shape}-{partitions}", + ) + for dtypes in FIELD_DTYPE_PAIRS + for shape in ((NITEMS_SMALL,), (NITEMS,), (NITEMS // 10, 100)) + for partitions in ((True, True), (True, False), (False, True), (False, False)) ] ) -def chunks_blocks_fixture(request): - return request.param - - -@pytest.fixture -def array_fixture(dtype_fixture, shape_fixture, chunks_blocks_fixture): +def array_fixture(request): + dtype_fixture, shape_fixture, chunks_blocks_fixture = request.param nelems = np.prod(shape_fixture) dt1, dt2 = dtype_fixture na1_ = np.linspace(0, nelems, nelems, dtype=dt1).reshape(shape_fixture) diff --git a/tests/ndarray/test_lazyudf.py b/tests/ndarray/test_lazyudf.py index b75f292d0..ce9bd3729 100644 --- a/tests/ndarray/test_lazyudf.py +++ b/tests/ndarray/test_lazyudf.py @@ -32,7 +32,10 @@ def udf1p(inputs_tuple, output, offset): @numba.jit(nopython=True) def udf1p_numba(inputs_tuple, output, offset): x = inputs_tuple[0] - output[:] = x + 1 + # The persistence test needs a compiled UDF, not NumPy temporary/broadcast + # lowering; scalar writes compile faster and exercise the same callback. + for i in range(x.size): + output[i] = x[i] + 1 @pytest.mark.parametrize("chunked_eval", [True, False]) @@ -469,39 +472,34 @@ def test_clip_logaddexp(shape, chunks, blocks, slices): np.testing.assert_allclose(expr, np.clip(np.logaddexp(npb, npa), 6, 12)) -def test_save_ludf(): +def test_save_ludf(tmp_path): shape = (23,) npa = np.arange(start=0, stop=np.prod(shape)).reshape(shape) - blosc2.remove_urlpath("a.b2nd") - array = blosc2.asarray(npa, urlpath="a.b2nd") + array = blosc2.asarray(npa, urlpath=str(tmp_path / "a.b2nd")) # Assert that shape is computed correctly npc = npa + 1 cparams = {"nthreads": 4} - urlpath = "lazyarray.b2nd" - blosc2.remove_urlpath(urlpath) + urlpath = str(tmp_path / "lazyarray.b2nd") expr = blosc2.lazyudf(udf1p, (array,), np.float64, cparams=cparams) - expr.save(urlpath=urlpath) - del expr - expr = blosc2.open(urlpath, mode="r", deserialize="full") + with pytest.raises(TypeError, match="PortableKernel"): + expr.save(urlpath=urlpath) + assert not (tmp_path / "lazyarray.b2nd").exists() assert isinstance(expr, blosc2.LazyUDF) res_lazyexpr = expr.compute() np.testing.assert_array_equal(res_lazyexpr[:], npc) - blosc2.remove_urlpath(urlpath) if blosc2._HAS_NUMBA: expr = blosc2.lazyudf(udf1p_numba, (array,), np.float64) - expr.save(urlpath=urlpath) - del expr - expr = blosc2.open(urlpath, mode="r", deserialize="full") + with pytest.raises(TypeError, match="PortableKernel"): + expr.save(urlpath=urlpath) + assert not (tmp_path / "lazyarray.b2nd").exists() assert isinstance(expr, blosc2.LazyUDF) res_lazyexpr = expr.compute() np.testing.assert_array_equal(res_lazyexpr[:], npc) - blosc2.remove_urlpath(urlpath) - def test_lazyudf_vlmeta_roundtrip(tmp_path): a_path = tmp_path / "a.b2nd" @@ -511,18 +509,11 @@ def test_lazyudf_vlmeta_roundtrip(tmp_path): expr.vlmeta["name"] = "increment" expr.vlmeta["attrs"] = {"version": 1} - expr.save(urlpath=str(expr_path)) - - restored = blosc2.open(str(expr_path), mode="r", deserialize="full") - - assert isinstance(restored, blosc2.LazyUDF) - assert restored.vlmeta["name"] == "increment" - assert restored.vlmeta["attrs"] == {"version": 1} - - with blosc2.open(str(expr_path), mode="r", deserialize="full") as restored_ctx: - assert isinstance(restored_ctx, blosc2.LazyUDF) - assert restored_ctx.vlmeta["name"] == "increment" - assert restored_ctx.vlmeta["attrs"] == {"version": 1} + with pytest.raises(TypeError, match="PortableKernel"): + expr.save(urlpath=str(expr_path)) + assert not expr_path.exists() + assert expr.vlmeta["name"] == "increment" + assert expr.vlmeta["attrs"] == {"version": 1} # Test get_chunk method diff --git a/tests/ndarray/test_ndarray.py b/tests/ndarray/test_ndarray.py index 5f8e631c1..44d0ee263 100644 --- a/tests/ndarray/test_ndarray.py +++ b/tests/ndarray/test_ndarray.py @@ -316,6 +316,156 @@ def test_arange_empty(start, stop, step): np.testing.assert_array_equal(a[:], b) +def test_ramp_lazy_constructors(): + cases = [ + ( + blosc2.arange(-7, 31, 3, dtype=np.int64, lazy=True, jit=False), + np.arange(-7, 31, 3, dtype=np.int64), + ), + ( + blosc2.linspace(-1.0, 2.0, num=19, dtype=np.float64, lazy=True, jit=False), + np.linspace(-1.0, 2.0, num=19, dtype=np.float64), + ), + ] + for lazy, expected in cases: + assert isinstance(lazy, blosc2.LazyArray) + result = lazy.compute(chunks=(8,), blocks=(4,)) + assert isinstance(result, blosc2.NDArray) + np.testing.assert_array_equal(result[:], expected) + + +def test_ramp_lazy_constructor_validation(): + with pytest.raises(NotImplementedError, match="C-order"): + blosc2.arange(10, lazy=True, c_order=False) + with pytest.raises(NotImplementedError, match="int64, float32, or float64"): + blosc2.arange(10, dtype=np.int32, lazy=True) + with pytest.raises(TypeError, match=r"compute\(\)"): + blosc2.arange(10, lazy=True, chunks=(4,)) + + +@pytest.mark.parametrize("dtype", [np.complex64, np.complex128]) +@pytest.mark.parametrize("constructor", ["arange", "linspace"]) +def test_complex_menudet_ramps(dtype, constructor, monkeypatch): + def no_legacy(*args, **kwargs): + pytest.fail("C-order complex ramps must use Menudet") + + monkeypatch.setattr(blosc2, "lazyudf", no_legacy) + shape = (5, 7) + if constructor == "arange": + args = (-2, 15.5, 0.5) + expected = np.arange(*args, dtype=dtype).reshape(shape) + else: + args = (1 + 2j, -3 - 0.25j, 35) + expected = np.linspace(*args, dtype=dtype).reshape(shape) + make = getattr(blosc2, constructor) + eager = make(*args, dtype=dtype, shape=shape, chunks=(3, 4), blocks=(2, 3), jit=True) + lazy = make(*args, dtype=dtype, shape=shape, lazy=True, jit=True) + assert not lazy.kernel.has_jit + assert eager.dtype == lazy.dtype == np.dtype(dtype) + tolerance = 2e-6 if dtype == np.complex64 else 1e-14 + np.testing.assert_allclose(eager[:], expected, rtol=tolerance, atol=tolerance) + np.testing.assert_allclose(lazy[1::2, 2::3], expected[1::2, 2::3], rtol=tolerance, atol=tolerance) + result = lazy.compute(chunks=(2, 5), blocks=(1, 3)) + np.testing.assert_allclose(result[:], expected, rtol=tolerance, atol=tolerance) + if constructor == "linspace": + assert eager[-1, -1] == result[-1, -1] == expected[-1, -1] + + +@pytest.mark.parametrize(("num", "endpoint"), [(0, True), (1, True), (1, False), (9, False), (9, True)]) +def test_complex_linspace_boundaries(num, endpoint): + start, stop = 0.3 + 0.7j, 0.9 - 0.2j + expected = np.linspace(start, stop, num, endpoint=endpoint) + # Inferred complex dtype, including the empty and singleton cases. + eager = blosc2.linspace(start, stop, num, endpoint=endpoint) + lazy = blosc2.linspace(start, stop, num, endpoint=endpoint, lazy=True) + np.testing.assert_allclose(eager[:], expected, rtol=1e-14) + np.testing.assert_allclose(lazy[:], expected, rtol=1e-14) + if num > 1 and endpoint: + assert eager[-1] == lazy[-1] == stop + + +@pytest.mark.parametrize(("dtype", "shape"), [(np.complex64, (11, 13)), (np.complex128, (3, 5, 7))]) +def test_complex_linspace_endpoint_persistence(dtype, shape, tmp_path): + start, stop = 0.3 + 0.7j, 0.9 - 0.2j + expected = np.linspace(start, stop, math.prod(shape), dtype=dtype).reshape(shape) + lazy = blosc2.linspace(start, stop, shape=shape, dtype=dtype, lazy=True) + path = tmp_path / "complex-linspace.b2nd" + lazy.save(path) + reopened = blosc2.open(path) + selection = tuple(slice(-2, None) for _ in shape) + tolerance = 2e-6 if dtype == np.complex64 else 1e-14 + np.testing.assert_allclose(reopened[selection], expected[selection], rtol=tolerance) + last = tuple(-1 for _ in shape) + assert reopened[last] == expected[last] + materialized = reopened.compute(chunks=(2,) * len(shape), blocks=(1,) * len(shape)) + np.testing.assert_allclose(materialized[:], expected, rtol=tolerance) + assert materialized[last] == expected[last] + + +def test_complex_arange_empty(): + eager = blosc2.arange(0, dtype=np.complex64) + lazy = blosc2.arange(0, dtype=np.complex64, lazy=True) + assert eager.shape == lazy.shape == (0,) + assert eager.dtype == lazy.dtype == np.dtype(np.complex64) + np.testing.assert_array_equal(lazy[:], np.array([], dtype=np.complex64)) + + +def test_large_arange_menudet_eager_parity(): + size = 4_000_000 + actual = blosc2.arange(-17, size * 3 - 17, 3, dtype=np.int64, chunks=(1_000_000,), blocks=(15_625,)) + expected = np.arange(-17, size * 3 - 17, 3, dtype=np.int64) + assert actual.shape == (size,) + np.testing.assert_array_equal(actual[:], expected) + + # 2D int64 eager ramp + shape = (2000, 2000) + actual_2d = blosc2.arange(0, 4_000_000, shape=shape, dtype=np.int64) + assert actual_2d.shape == shape + np.testing.assert_array_equal(actual_2d[:], np.arange(4_000_000, dtype=np.int64).reshape(shape)) + + # Float64 eager ramp + actual_f64 = blosc2.arange(0.0, 4_000_000.0, 1.0, dtype=np.float64) + np.testing.assert_array_equal(actual_f64[:], np.arange(4_000_000, dtype=np.float64)) + + # Float32 eager ramp + actual_f32 = blosc2.arange(0.0, 4_000_000.0, 1.0, dtype=np.float32) + np.testing.assert_allclose(actual_f32[:], np.arange(4_000_000, dtype=np.float32)) + + +def test_large_linspace_menudet_eager_parity(): + size = 4_000_000 + actual = blosc2.linspace(0.0, 1.0, size, dtype=np.float64) + expected = np.linspace(0.0, 1.0, size, dtype=np.float64) + assert actual.shape == (size,) + np.testing.assert_allclose(actual[:], expected) + + # 2D linspace + shape = (2000, 2000) + actual_2d = blosc2.linspace(0.0, 1.0, size, shape=shape, dtype=np.float64) + assert actual_2d.shape == shape + np.testing.assert_allclose(actual_2d[:], expected.reshape(shape)) + + +def test_lazy_arange_and_linspace(): + for dt in [np.int64, np.float64, np.float32]: + a1 = blosc2.arange(100, dtype=dt, lazy=True) + assert isinstance(a1, blosc2.portable_lazy.PortableLazyArray) + np.testing.assert_allclose(a1[:], np.arange(100, dtype=dt)) + + a2 = blosc2.arange(0, 100, shape=(10, 10), dtype=dt, lazy=True) + assert a2.shape == (10, 10) + np.testing.assert_allclose(a2[:], np.arange(100, dtype=dt).reshape(10, 10)) + + for dt in [np.float64, np.float32]: + l1 = blosc2.linspace(0.0, 1.0, 100, dtype=dt, lazy=True) + assert isinstance(l1, blosc2.portable_lazy.PortableLazyArray) + np.testing.assert_allclose(l1[:], np.linspace(0.0, 1.0, 100, dtype=dt)) + + l2 = blosc2.linspace(0.0, 1.0, 100, shape=(10, 10), dtype=dt, lazy=True) + assert l2.shape == (10, 10) + np.testing.assert_allclose(l2[:], np.linspace(0.0, 1.0, 100, dtype=dt).reshape(10, 10)) + + @pytest.mark.parametrize( ("ss", "shape", "dtype", "chunks", "blocks"), [ @@ -323,6 +473,7 @@ def test_arange_empty(start, stop, step): ((0, 7), (10,), np.float64, (5,), (2,)), ((0, 7), (10,), np.complex64, (5,), (2,)), ((0, 6), (10,), np.complex128, (5,), (2,)), + ((1 + 2j, -3 - 0.25j), (5, 7), np.complex128, (3, 4), (2, 3)), ((-1, 7), (10, 10), np.float32, (10, 2), (2, 2)), ], ) @@ -363,8 +514,9 @@ def test_linspace(ss, shape, dtype, chunks, blocks, endpoint, c_order): @pytest.mark.parametrize(("N", "M"), [(10, None), (10, 20), (20, 10)]) @pytest.mark.parametrize("k", [-1, 0, 1, 2, 3]) -@pytest.mark.parametrize("dtype", [np.float32, np.float64, np.int32]) -@pytest.mark.parametrize("chunks", [(5, 6), (10, 9)]) +@pytest.mark.parametrize( + ("dtype", "chunks"), [(np.float32, (5, 6)), (np.float64, (10, 9)), (np.int32, (5, 6))] +) def test_eye(k, N, M, dtype, chunks): a = np.eye(N, M, k, dtype=dtype) b = blosc2.eye(N, M, k, dtype=dtype, chunks=chunks) @@ -373,6 +525,39 @@ def test_eye(k, N, M, dtype, chunks): np.testing.assert_allclose(a, b[:]) +@pytest.mark.parametrize("jit", [False, True]) +@pytest.mark.parametrize("clevel", [0, 5]) +@pytest.mark.skipif(blosc2.IS_WASM, reason="Native prefilter scheduling is unavailable on WASM") +def test_eye_portable_edges_and_storage(jit, clevel, tmp_path, monkeypatch): + def forbidden(*args, **kwargs): + pytest.fail("Numeric eye must not use the Python LazyUDF callback") + + monkeypatch.setattr(blosc2, "lazyudf", forbidden) + for k in (-21, -3, 0, 4, 30): + path = tmp_path / f"eye-{k}.b2nd" + result = blosc2.eye( + 17, + 23, + k=k, + dtype="int16", + chunks=(7, 9), + blocks=(4, 5), + jit=jit, + urlpath=path, + cparams={"nthreads": 2, "clevel": clevel}, + ) + np.testing.assert_array_equal(result[:], np.eye(17, 23, k=k, dtype="int16")) + np.testing.assert_array_equal(blosc2.open(path)[:], result[:]) + + +@pytest.mark.parametrize("dtype", ["bool", "uint8", "float32", "complex128"]) +def test_eye_dtype_and_empty(dtype): + for shape in ((0, 3), (3, 0), (9, 13)): + result = blosc2.eye(*shape, dtype=dtype, jit=False) + assert result.dtype == np.dtype(dtype) + np.testing.assert_array_equal(result[:], np.eye(*shape, dtype=dtype)) + + @pytest.mark.parametrize( ("it", "shape", "dtype", "chunks", "blocks"), [ diff --git a/tests/ndarray/test_reductions.py b/tests/ndarray/test_reductions.py index 89982a550..df4951068 100644 --- a/tests/ndarray/test_reductions.py +++ b/tests/ndarray/test_reductions.py @@ -258,30 +258,35 @@ def test_reduce_params(array_fixture, axis, keepdims, dtype_out, reduce_op, kwar # TODO: "prod" is not supported here because it overflows with current values @pytest.mark.parametrize( - "reduce_op", + ("reduce_op", "shape_fixture", "axis"), [ - "cumulative_sum", - "sum", - "min", - "mean", - "argmax", - pytest.param("max", marks=pytest.mark.heavy), - pytest.param("std", marks=pytest.mark.heavy), - pytest.param("var", marks=pytest.mark.heavy), - pytest.param("any", marks=pytest.mark.heavy), - pytest.param("all", marks=pytest.mark.heavy), - pytest.param("argmin", marks=pytest.mark.heavy), + pytest.param( + op, + shape, + axis, + marks=[] if op in {"cumulative_sum", "sum", "min", "mean", "argmax"} else pytest.mark.heavy, + ) + for op in ( + "cumulative_sum", + "sum", + "min", + "mean", + "argmax", + "max", + "std", + "var", + "any", + "all", + "argmin", + ) + for shape in ((NITEMS_SMALL,), (NITEMS,), (NITEMS // 100, 100)) + for axis in (None, 0, 1) + if (axis is None or axis < len(shape)) and not (op == "cumulative_sum" and axis is None) ], + indirect=["shape_fixture"], ) -@pytest.mark.parametrize("axis", [None, 0, 1]) def test_reduce_expr_arr(array_fixture, axis, reduce_op): a1, a2, a3, a4, na1, na2, na3, na4 = array_fixture - if axis is not None: - if len(a1.shape) <= axis: - return - else: - if reduce_op == "cumulative_sum": - return expr = a1 + a2 - a3 * a4 nres = eval("na1 + na2 - na3 * na4") tol = 1e-12 if a1.dtype == "float64" else 5e-5 @@ -311,8 +316,9 @@ def test_reduce_expr_arr(array_fixture, axis, reduce_op): @pytest.mark.parametrize( "shapes", [ + # Both former small sizes used identical ranks/broadcast directions. + # Keep one small geometry and the opt-in large-array qualification. ((5, 5, 5), (5, 5), (5,)), - ((10, 10, 10), (10, 10), (10,)), pytest.param(((100, 100, 100), (100, 100), (100,)), marks=pytest.mark.heavy), ], ) diff --git a/tests/ndarray/test_safer_jit.py b/tests/ndarray/test_safer_jit.py index 1974985d2..891bf2c71 100644 --- a/tests/ndarray/test_safer_jit.py +++ b/tests/ndarray/test_safer_jit.py @@ -17,7 +17,7 @@ HERE = Path(__file__).resolve().parent -def run_probe(tmp_path, backend="tcc", mode="on", trace=False, **overrides): +def run_probe(tmp_path, backend="tcc", mode="on", trace=False, workload="all", **overrides): env = os.environ.copy() for name in list(env): if name.startswith(("ME_DSL_", "BLOSC_ME_JIT")) or name in ("CC", "CFLAGS"): @@ -25,7 +25,7 @@ def run_probe(tmp_path, backend="tcc", mode="on", trace=False, **overrides): env.update(PYTHONDONTWRITEBYTECODE="1", TMPDIR=str(tmp_path), ME_DSL_TRACE="1" if trace else "0") env.update(overrides) return subprocess.run( - [sys.executable, str(HERE / "safer_jit_probe.py"), backend, mode], + [sys.executable, str(HERE / "safer_jit_probe.py"), backend, mode, workload], env=env, text=True, capture_output=True, @@ -158,12 +158,14 @@ def test_cc_failure_is_quiet(tmp_path, failure, trace): def test_cc_reuses_disk_cache_in_fresh_process(tmp_path): if shutil.which("cc") is None: pytest.skip("System compiler unavailable") - cold = run_probe(tmp_path, backend="cc", trace=True) - warm = run_probe(tmp_path, backend="cc", trace=True) + # One real compiled kernel is enough to prove cross-process disk reuse. + # Other probes retain the full constructor/expression/UDF/reduction workload. + cold = run_probe(tmp_path, backend="cc", trace=True, workload="cache", CFLAGS="-O0") + warm = run_probe(tmp_path, backend="cc", trace=True, workload="cache", CFLAGS="-O0") assert "jit runtime built:" in cold.stderr assert "source=disk-cache" in warm.stderr assert "jit runtime built:" not in warm.stderr - assert list((tmp_path / "miniexpr-jit").glob("kernel_*.meta")) + assert len(list((tmp_path / "miniexpr-jit").glob("kernel_*.meta"))) == 1 def test_cc_compiler_output_is_opt_in(tmp_path): diff --git a/tests/ndarray/test_stringarrays.py b/tests/ndarray/test_stringarrays.py index e6f371140..7d662d26f 100644 --- a/tests/ndarray/test_stringarrays.py +++ b/tests/ndarray/test_stringarrays.py @@ -31,25 +31,12 @@ def make_unicode_array(shape, maxlen=16): # Parameter grids # ---------------------------------- -SHAPES = [ - (12,), - (12, 6), - (3, 4, 5), -] - -CHUNKS = [ - None, - (4,), - (7, 4), - (2, 2, 5), -] - -BLOCKS = [ - None, - (3,), - (3, 3), - (1, 2, 5), +UNICODE_LAYOUTS = [ + ((12,), (4,), (3,)), + ((12, 6), (7, 4), (3, 3)), + ((3, 4, 5), (2, 2, 5), (1, 2, 5)), ] +SHAPES = [shape for shape, _, _ in UNICODE_LAYOUTS] # ---------------------------------- @@ -57,17 +44,19 @@ def make_unicode_array(shape, maxlen=16): # ---------------------------------- -@pytest.mark.parametrize("shape", SHAPES) -@pytest.mark.parametrize("chunks", CHUNKS) -@pytest.mark.parametrize("blocks", BLOCKS) +@pytest.mark.parametrize( + ("shape", "chunks", "blocks"), + [ + (shape, chunks if explicit_chunks else None, blocks if explicit_blocks else None) + for shape, chunks, blocks in UNICODE_LAYOUTS + for explicit_chunks in (False, True) + for explicit_blocks in (False, True) + ], +) def test_unicode_roundtrip_in_memory(shape, chunks, blocks): arr = make_unicode_array(shape) - b2 = blosc2.asarray( - arr, - chunks=chunks if chunks and len(chunks) == arr.ndim else None, - blocks=blocks if blocks and len(blocks) == arr.ndim else None, - ) + b2 = blosc2.asarray(arr, chunks=chunks, blocks=blocks) assert b2.dtype == arr.dtype assert np.array_equal(b2, arr) diff --git a/tests/test_b2objects.py b/tests/test_b2objects.py index 9eb0cde16..71903a951 100644 --- a/tests/test_b2objects.py +++ b/tests/test_b2objects.py @@ -10,6 +10,7 @@ from pathlib import Path import numpy as np +import pytest import blosc2 import blosc2.c2array as blosc2_c2array @@ -148,27 +149,25 @@ def test_lazyudf_from_cframe_roundtrip(tmp_path): a = blosc2.asarray(np.arange(5, dtype=np.float64), urlpath=tmp_path / "a.b2nd", mode="w") b = blosc2.asarray(np.arange(5, dtype=np.float64) * 2, urlpath=tmp_path / "b.b2nd", mode="w") expr = blosc2.lazyudf(kernel_add_square, (a, b), dtype=np.float64) - carrier = blosc2.ndarray_from_cframe(expr.to_cframe()) + restored = blosc2.from_cframe(expr.to_cframe()) + np.testing.assert_allclose(restored[:], (np.arange(5, dtype=np.float64) * 3) ** 2) + from blosc2.msgpack_utils import msgpack_packb, msgpack_unpackb - assert carrier.schunk.meta["b2o"] == {"kind": "lazyudf", "version": 1} - payload = carrier.schunk.vlmeta["b2o"] - assert payload["kind"] == "lazyudf" - assert payload["version"] == 1 - assert payload["function_kind"] == "dsl" - assert payload["dsl_version"] == 1 - assert payload["name"] == "kernel_add_square" - assert "kernel_add_square" in payload["udf_source"] - assert payload["dtype"] == np.dtype(np.float64).str - assert payload["shape"] == [5] - assert payload["operands"] == { - "o0": {"kind": "urlpath", "version": 1, "urlpath": (tmp_path / "a.b2nd").as_posix()}, - "o1": {"kind": "urlpath", "version": 1, "urlpath": (tmp_path / "b.b2nd").as_posix()}, - } + offset = np.float32(2) - restored = blosc2.from_cframe(expr.to_cframe(), deserialize="full") + @blosc2.dsl_kernel + def captured(x, scale): + return x * scale + offset - assert isinstance(restored, blosc2.LazyUDF) - np.testing.assert_allclose(restored[:], (np.arange(5, dtype=np.float64) * 3) ** 2) + authored = blosc2.lazyudf(captured, (a, np.int16(3)), dtype="float64") + authored.vlmeta["label"] = "captured" + packed = msgpack_packb([authored]) + framed = authored.to_cframe() + offset = np.float32(99) + np.testing.assert_array_equal(msgpack_unpackb(packed)[0][:], np.arange(5) * 3 + 2) + framed_recipe = blosc2.from_cframe(framed) + np.testing.assert_array_equal(framed_recipe[:], np.arange(5) * 3 + 2) + assert framed_recipe.vlmeta["label"] == "captured" def test_lazyudf_open_roundtrip(tmp_path): @@ -178,10 +177,27 @@ def test_lazyudf_open_roundtrip(tmp_path): urlpath = tmp_path / "expr.b2nd" expr.save(urlpath) - restored = blosc2.open(urlpath, mode="r", deserialize="full") - - assert isinstance(restored, blosc2.LazyUDF) + restored = blosc2.open(urlpath, mode="r") np.testing.assert_allclose(restored[:], (np.arange(5, dtype=np.float64) * 3) ** 2) + nested = expr + 1 + nested.save(tmp_path / "nested.b2nd") + np.testing.assert_array_equal(blosc2.open(tmp_path / "nested.b2nd")[:], (np.arange(5) * 3) ** 2 + 1) + for body, expected in ( + ("print(x)\n return x", "print"), + ("return callback(x)", "invalid_source"), + ("return block_sum(x)", "block scalar"), + ): + invalid = blosc2.DSLKernel.from_source(f"def invalid(x):\n {body}\n") + bad = blosc2.lazyudf(invalid, (a,), dtype="float64") + before = urlpath.read_bytes() + with pytest.raises((blosc2.PortableArtifactError, ValueError), match=expected): + bad.save(urlpath, mode="w") + assert urlpath.read_bytes() == before + fixture = Path(__file__).parent / "data" / "legacy_lazyudf_v1" / "expr.b2nd" + legacy = blosc2.open(fixture, deserialize="full") + with pytest.raises(TypeError, match="legacy"): + legacy.save(urlpath, mode="w") + assert urlpath.read_bytes() == before def test_b2z_bundle_with_lazy_recipes_opens_read_only(tmp_path): @@ -197,13 +213,11 @@ def test_b2z_bundle_with_lazy_recipes_opens_read_only(tmp_path): udf = blosc2.lazyudf(kernel_add_square, (a, b), dtype=np.float64, shape=a.shape) store["/recipes/expr"] = blosc2.ndarray_from_cframe(expr.to_cframe()) - store["/recipes/udf"] = blosc2.ndarray_from_cframe(udf.to_cframe()) + store["/recipes/udf"] = udf with blosc2.open(str(bundle_path), mode="r", deserialize="full") as store: restored_expr = store["/recipes/expr"] - restored_udf = store["/recipes/udf"] assert isinstance(restored_expr, blosc2.LazyExpr) - assert isinstance(restored_udf, blosc2.LazyUDF) np.testing.assert_allclose(restored_expr.compute()[:], np.arange(5, dtype=np.float64) * 3) - np.testing.assert_allclose(restored_udf.compute()[:], (np.arange(5, dtype=np.float64) * 3) ** 2) + np.testing.assert_allclose(store["/recipes/udf"][:], (np.arange(5, dtype=np.float64) * 3) ** 2) diff --git a/tests/test_bench_evaluate_numpy_parity.py b/tests/test_bench_evaluate_numpy_parity.py new file mode 100644 index 000000000..94f3cb642 --- /dev/null +++ b/tests/test_bench_evaluate_numpy_parity.py @@ -0,0 +1,90 @@ +"""Qualification and output contracts of the resident-output comparison script.""" + +import json +import os +import random +import runpy +from pathlib import Path + +import numpy as np +import pytest + +import blosc2 + + +@pytest.fixture +def benchmark(): + return runpy.run_path(str(Path(__file__).resolve().parents[1] / "bench/evaluate-numpy-parity.py")) + + +def test_benchmark_rejects_wrong_integer_values_before_timing(benchmark, monkeypatch): + inputs = {"x": np.array([2**60], dtype="int64")} + + def wrong_result(expression, local_dict, out=None): + if out is None: + out = np.empty_like(local_dict["x"]) + out[...] = local_dict["x"] + 1 + return out + + monkeypatch.setattr(blosc2, "evaluate", wrong_result) + with pytest.raises(AssertionError): + benchmark["compare_case"]("x", inputs, 1, 0, random.Random(42)) + + +def test_benchmark_rejects_engine_promotion_differences(benchmark, monkeypatch): + from types import SimpleNamespace + + external = SimpleNamespace(evaluate=lambda *args, **kwargs: np.arange(17, dtype="float64")) + monkeypatch.setitem(benchmark["compare_case"].__globals__, "ne", external) + x = np.arange(17, dtype="int64") + result = benchmark["compare_case"]("minimum(x,y)", {"x": x, "y": x + 1}, 1, 0, random.Random(42)) + assert result["numexpr"] is None + assert "result dtype differs" in result["numexpr_error"] + assert result["numpy"] > 0 + assert result["blosc2"] > 0 + + +@pytest.mark.parametrize("absent", [False, True]) +def test_benchmark_cli_qualifies_explicit_outputs(benchmark, monkeypatch, tmp_path, capsys, absent): + if absent: + monkeypatch.setitem(benchmark["main"].__globals__, "ne", None) + numexpr = benchmark["main"].__globals__["ne"] + + report = tmp_path / "parity.json" + monkeypatch.setenv("ME_DSL_JIT_COMPILER", os.environ.get("ME_DSL_JIT_COMPILER", "tcc")) + monkeypatch.setattr( + "sys.argv", + [ + "evaluate-numpy-parity.py", + "--items", + "257", + "--cases", + "linear", + "complex", + "--samples", + "1", + "--warmups", + "0", + "--threads", + "2", + "--json", + str(report), + ], + ) + previous = blosc2.nthreads + previous_ne = numexpr.get_num_threads() if numexpr is not None else None + try: + benchmark["main"]() + finally: + blosc2.set_nthreads(previous) + if numexpr is not None: + numexpr.set_num_threads(previous_ne) + results = json.loads(report.read_text())["results"] + assert len(results) == 2 + assert all(result["status"] == "qualified" for result in results) + assert all(result["numpy"] > 0 and result["blosc2"] > 0 for result in results) + assert all(result["numexpr"] is None or result["numexpr"] > 0 for result in results) + if absent: + assert all(result["numexpr"] is None for result in results) + assert results[-1]["route"] == "numpy/eager" + assert "shared warmed NumPy out" in capsys.readouterr().out diff --git a/tests/test_bench_menudet_engines.py b/tests/test_bench_menudet_engines.py new file mode 100644 index 000000000..e2ed6a3ea --- /dev/null +++ b/tests/test_bench_menudet_engines.py @@ -0,0 +1,201 @@ +"""Scalar and elementwise correctness of the engine comparison benchmark.""" + +import os +import random +import runpy +import sys +from pathlib import Path + +import numpy as np +import pytest + +import blosc2 + + +@pytest.mark.parametrize("reduc", [None, "sum"]) +def test_cold_selected_engine_results(engine_benchmark, reduc): + inputs, values = engine_benchmark["build_operands"](257, "numpy", "int64") + expected = values.sum() if reduc else values + for name in engine_benchmark["ENGINES"]: + with engine_benchmark["cold_preparation"](): + result = engine_benchmark["make_engines"](inputs, "numpy", reduc, selected=name)[name]() + if isinstance(result, blosc2.NDArray): + result = result[:] + np.testing.assert_array_equal(result, expected) + + +def test_cold_samples_rebuild_after_qualification(engine_benchmark): + created = [] + previous = os.environ.get("ME_DSL_JIT_CACHE_DIR") + + def factory(name): + assert name == "probe" + created.append(os.environ["ME_DSL_JIT_CACHE_DIR"]) + assert os.environ["ME_DSL_JIT_POS_CACHE"] == "0" + return lambda: np.arange(3) + + times = engine_benchmark["benchmark"]( + {"probe": lambda: np.arange(3)}, np.arange(3), 3, 0, random.Random(42), cold_factory=factory + ) + assert times["probe"] > 0 + assert len(set(created)) == 3 + assert os.environ.get("ME_DSL_JIT_CACHE_DIR") == previous + + +@pytest.fixture(scope="module") +def engine_benchmark(): + pytest.importorskip("numexpr") + return runpy.run_path(str(Path(__file__).resolve().parents[1] / "bench" / "menudet-engines.py")) + + +@pytest.mark.parametrize("reduc", [None, "sum", "mean", "min", "max", "any", "all"]) +@pytest.mark.parametrize(("size", "kind"), [(1, "numpy"), (257, "blosc2")]) +def test_engine_results(engine_benchmark, size, kind, reduc): + inputs, values = engine_benchmark["build_operands"](size, "numpy") + expected = getattr(np, reduc)(values) if reduc else values + if kind == "blosc2": + # Multiple chunks plus a partial tail for the nontrivial size. + inputs = {name: blosc2.asarray(value, chunks=(128,), blocks=(32,)) for name, value in inputs.items()} + engines = engine_benchmark["make_engines"](inputs, kind, reduc) + assert tuple(engines) == engine_benchmark["ENGINES"] + for name, operation in engines.items(): + result = operation() + if reduc: + assert np.ndim(result) == 0, name + np.testing.assert_allclose(result, expected, rtol=1e-12, atol=1e-12, err_msg=name) + else: + if name == "LazyExpr" or (kind == "blosc2" and name == "Menudet"): + assert isinstance(result, blosc2.NDArray), name + assert result.cparams.clevel == 5, name + if kind == "blosc2": + assert result.chunks == inputs["x"].chunks, name + assert result.blocks == inputs["x"].blocks, name + result = result[:] + else: + assert isinstance(result, np.ndarray), name + np.testing.assert_array_equal(result, expected, err_msg=name) + + +@pytest.mark.parametrize("kind", ["numpy", "blosc2"]) +def test_evaluate_column_calls_public_api_every_time(engine_benchmark, monkeypatch, kind): + inputs, expected = engine_benchmark["build_operands"](257, kind) + calls = [] + + def evaluate(expression, *, local_dict): + calls.append((expression, local_dict)) + return expected.copy() + + monkeypatch.setattr(blosc2, "evaluate", evaluate) + engines = engine_benchmark["make_engines"](inputs, kind) + first = engines["evaluate"]() + second = engines["evaluate"]() + assert first is not second + assert calls == [(engine_benchmark["EXPRESSION"], inputs)] * 2 + + +def test_allocation_control_outputs(engine_benchmark): + inputs, expected = engine_benchmark["build_operands"](257, "numpy", "int64") + engines = engine_benchmark["make_allocation_engines"](inputs) + reused = engines["numexpr reused"]() + np.testing.assert_array_equal(reused, expected) + assert engines["evaluate reused"]() is reused + for name in ("numexpr fresh", "evaluate fresh"): + first = engines[name]() + second = engines[name]() + assert first is not second + np.testing.assert_array_equal(first, expected) + np.testing.assert_array_equal(reused, expected) + + +def test_allocation_control_cli(engine_benchmark, monkeypatch, capsys): + monkeypatch.setattr( + sys, + "argv", + [ + "menudet-engines.py", + "--items", + "17", + "--samples", + "1", + "--warmups", + "1", + "--operands", + "numpy", + "--allocation-control", + ], + ) + engine_benchmark["main"]() + text = capsys.readouterr().out + assert "main table above remains fresh-output" in text + assert "numexpr reused" in text + assert "evaluate reused" in text + + +@pytest.mark.parametrize("backend", [None, "tcc", "cc"]) +def test_jit_backend_selection(engine_benchmark, monkeypatch, capsys, backend): + main = engine_benchmark["main"] + namespace = main.__globals__ + monkeypatch.setenv("ME_DSL_JIT_COMPILER", "tcc") + monkeypatch.setenv("BLOSC_ME_JIT", "0") + argv = ["menudet-engines.py", "--items", "1", "--samples", "1", "--warmups", "1"] + argv += ["--dtype", "uint64", "--codec", "LZ4", "--clevel", "3"] + if backend: + argv += ["--jit", backend] + monkeypatch.setattr(sys, "argv", argv) + observed = [] + + def make_engines(inputs, kind, reduc, cparams=None): + assert inputs["x"].dtype == np.dtype("uint64") + assert cparams.codec == blosc2.Codec.LZ4 + assert cparams.clevel == 3 + observed.append((kind, os.environ["ME_DSL_JIT_COMPILER"])) + return {name: lambda: np.zeros(1) for name in namespace["ENGINES"]} + + monkeypatch.setitem(namespace, "make_engines", make_engines) + monkeypatch.setattr(blosc2, "set_nthreads", lambda threads: None) + monkeypatch.setattr(namespace["ne"], "set_num_threads", lambda threads: None) + main() + expected = backend or "tcc" + assert observed == [("numpy", expected), ("blosc2", expected)] + assert f"Miniexpr JIT backend request: {expected}" in capsys.readouterr().out + + +@pytest.mark.parametrize("dtype", ["int16", "uint64", "float32"]) +@pytest.mark.parametrize("kind", ["numpy", "blosc2"]) +def test_arange_operands_and_compression(engine_benchmark, dtype, kind): + cparams = blosc2.CParams(codec=blosc2.Codec.LZ4, clevel=3) + # Cross a narrow-integer wrap boundary without relying on Python scalar casts. + size = 40003 if dtype == "int16" else 257 + inputs, expected = engine_benchmark["build_operands"](size, kind, dtype, cparams) + x, y = np.arange(size, dtype=dtype), np.arange(1, size + 1, dtype=dtype) + for name, values in (("x", x), ("y", y)): + operand = inputs[name] + assert operand.dtype == np.dtype(dtype) + if kind == "blosc2": + assert operand.cparams.codec == blosc2.Codec.LZ4 + assert operand.cparams.clevel == 3 + operand = operand[:] + np.testing.assert_array_equal(operand, values) + np.testing.assert_array_equal(expected, x + (y - 1)) + for name in ("LazyExpr", "Menudet"): + if kind == "numpy" and name == "Menudet": + continue + result = engine_benchmark["make_engines"](inputs, kind, cparams=cparams)[name]() + assert result.cparams.codec == blosc2.Codec.LZ4 + assert result.cparams.clevel == 3 + np.testing.assert_array_equal(result[:], expected) + + +def test_benchmark_reports_nonparity(engine_benchmark): + import random + + engines = { + "NumPy": lambda: np.array([1], dtype="int16"), + "numexpr": lambda: np.array([2], dtype="int32"), + } + failures = {} + times = engine_benchmark["benchmark"]( + engines, np.array([1], dtype="int16"), 1, 0, random.Random(42), failures=failures + ) + assert set(times) == {"NumPy"} + assert failures == {"numexpr": "different numerical results"} diff --git a/tests/test_cache_lock.py b/tests/test_cache_lock.py index 4b1215f4a..f75bee460 100644 --- a/tests/test_cache_lock.py +++ b/tests/test_cache_lock.py @@ -22,5 +22,7 @@ def test_windows_cache_lock_does_not_initialize_byte(tmp_path, monkeypatch, bloc with path.open("a+b") as file: cache.lock_cache_file(file, blocking=blocking) assert file.tell() == 0 - assert calls == [(file.fileno(), msvcrt.LK_LOCK if blocking else msvcrt.LK_NBLCK, 1)] + # Blocking mode retries LK_NBLCK explicitly rather than using LK_LOCK's + # fixed ten-second wait budget. The uncontended attempt is identical. + assert calls == [(file.fileno(), msvcrt.LK_NBLCK, 1)] assert path.read_bytes() == b"" diff --git a/tests/test_chunk_jit.py b/tests/test_chunk_jit.py new file mode 100644 index 000000000..241b864ed --- /dev/null +++ b/tests/test_chunk_jit.py @@ -0,0 +1,188 @@ +"""Chunk fallback must retain native lowering and explicit execution policy.""" + +import importlib + +import numpy as np +import pytest + +import blosc2 + +pytestmark = pytest.mark.skipif( + blosc2.IS_WASM, reason="Native graph JIT and host threads are unavailable on WASM" +) + + +@pytest.mark.parametrize("jit", [False, True]) +def test_chunk_lowering_respects_jit_policy(native_graph_runtime, monkeypatch, jit): + native = importlib.import_module("blosc2.native_graph") + lazy = importlib.import_module("blosc2.lazyexpr") + original = native.lower_native_graph + plans = [] + + def lower(*args, **kwargs): + assert kwargs["jit"] is jit + result = original(*args, **kwargs) + plans.append(result[0]) + return result + + monkeypatch.setattr(native, "lower_native_graph", lower) + x = np.arange(100_003.0, dtype="float64") + output = np.empty_like(x) + with blosc2.jit_options(jit=jit): + result = lazy.evaluate_chunk("x * 2 + 1", {"x": x}, out=output) + assert result is output + np.testing.assert_array_equal(result, x * 2 + 1) + assert len(plans) == 1 + if not jit: + assert not plans[0].has_jit + + +def test_chunk_execution_failure_is_not_replayed(native_graph_runtime, monkeypatch): + native = importlib.import_module("blosc2.native_graph") + lazy = importlib.import_module("blosc2.lazyexpr") + + class FailedSchedule: + def info(self): + return {"shape": (3,), "dtype": np.dtype("float64")} + + def execute(self, *args, **kwargs): + raise ArithmeticError("native execution failed") + + class Plan: + def info(self): + return {} + + def specialize(self, *args, **kwargs): + return FailedSchedule() + + monkeypatch.setattr(native, "lower_native_graph", lambda expr, **kwargs: (Plan(), expr.operands, False)) + with pytest.raises(ArithmeticError, match="native execution failed"): + lazy.evaluate_chunk("x + 1", {"x": np.ones(3)}) + + +@pytest.mark.parametrize("policy", [{"jit_backend": "cc"}, {"fp_accuracy": blosc2.FPAccuracy.HIGH}]) +def test_chunk_does_not_compile_with_unsupported_graph_policy(native_graph_runtime, monkeypatch, policy): + native = importlib.import_module("blosc2.native_graph") + lazy = importlib.import_module("blosc2.lazyexpr") + original = native.lower_native_graph + calls = [] + + def lower(*args, **kwargs): + calls.append(kwargs["jit"]) + return original(*args, **kwargs) + + monkeypatch.setattr(native, "lower_native_graph", lower) + x = np.arange(17.0) + with blosc2.jit_options(**policy): + result = lazy.evaluate_chunk("x + 1", {"x": x}) + np.testing.assert_array_equal(result, x + 1) + assert calls == [False] + + +def test_integral_math_uses_native_parallel_tasks(native_graph_runtime): + x = np.arange(600_003, dtype="int64") % 97 + y = (x % 31) + 1 + for expression, expected in [("minimum(x,y)", np.minimum(x, y)), ("fmod(x,y)", np.fmod(x, y))]: + plan = blosc2.NativeGraph.from_expression(expression, {"x": x.dtype, "y": y.dtype}, jit=True) + assert plan.info()["partitionable"] + out = np.empty_like(x) + result, report = plan.evaluate({"x": x, "y": y}, out=out, workers=4, return_report=True) + assert result is out + assert report["tasks"] == 4 + np.testing.assert_array_equal(result, expected) + + +def test_small_transcendental_map_uses_caller_and_workers(native_graph_runtime, monkeypatch): + import blosc2.resident_execution as resident + + monkeypatch.setattr(blosc2.blosc2_ext, "native_graph_executor_available", lambda: False) + pool = resident.resident_pool() + submissions = [] + + class RecordingPool: + def submit(self, *args): + future = pool.submit(*args) + submissions.append(future) + return future + + monkeypatch.setattr(resident, "resident_pool", RecordingPool) + x = np.linspace(0.1, 1.0, 100_003) + plan = blosc2.NativeGraph.from_expression("sin(x) + cos(x)", {"x": x.dtype}, jit=False) + expected = plan.evaluate({"x": x}) + result, report = plan.evaluate({"x": x}, workers=8, return_report=True) + assert report["tasks"] == 4 + assert len(submissions) == 3 + assert all(future.done() for future in submissions) + assert report["jit_stages"] == 0 + np.testing.assert_array_equal(result, expected) + + +def test_native_executor_joins_after_interrupted_wait(native_graph_runtime, monkeypatch): + import blosc2.resident_execution as resident + + monkeypatch.setattr(blosc2.blosc2_ext, "native_graph_executor_available", lambda: False) + pool = resident.resident_pool() + submitted = [] + + class InterruptedFuture: + def __init__(self, future): + self.future = future + self.calls = 0 + + def result(self): + self.calls += 1 + if self.calls == 1: + raise KeyboardInterrupt("interrupted join") + return self.future.result() + + def done(self): + return self.calls > 1 and self.future.done() + + class InterruptedPool: + def submit(self, *args): + future = pool.submit(*args) + submitted.append(future) + return InterruptedFuture(future) + + monkeypatch.setattr(resident, "resident_pool", InterruptedPool) + x = np.arange(600_003.0) + plan = blosc2.NativeGraph.from_expression("x + 1", {"x": x.dtype}) + with pytest.raises(KeyboardInterrupt, match="interrupted join"): + plan.evaluate({"x": x}, workers=4) + assert len(submitted) == 3 + assert all(future.done() for future in submitted) + + +def test_native_executor_rejects_late_job_after_enqueue_failure(native_graph_runtime, monkeypatch): + from threading import Event + + import blosc2.resident_execution as resident + + monkeypatch.setattr(blosc2.blosc2_ext, "native_graph_executor_available", lambda: False) + pool = resident.resident_pool() + release = Event() + submitted = [] + + def late_job(function, args): + assert release.wait(timeout=10) + function(*args) + + class EnqueueThenFailPool: + def submit(self, function, *args): + submitted.append(pool.submit(late_job, function, args)) + raise RuntimeError("failed after enqueue") + + monkeypatch.setattr(resident, "resident_pool", EnqueueThenFailPool) + x = np.arange(600_003.0) + out = np.full_like(x, -999.0) + plan = blosc2.NativeGraph.from_expression("x + 1", {"x": x.dtype}) + try: + with pytest.raises(RuntimeError, match="failed after enqueue"): + plan.evaluate({"x": x}, out=out, workers=4) + finally: + release.set() + for future in submitted: + future.result(timeout=10) + # The late job must not dereference invocation pointers after the caller + # returned, even though submit() never supplied its Future for joining. + np.testing.assert_array_equal(out, -999.0) diff --git a/tests/test_compressors.py b/tests/test_compressors.py index 888bb4088..ae340b660 100644 --- a/tests/test_compressors.py +++ b/tests/test_compressors.py @@ -10,18 +10,22 @@ import blosc2 -@pytest.mark.parametrize("gil", [True, False]) @pytest.mark.parametrize( - ("clevel", "codec"), + ("clevel", "codec", "filt", "gil"), [ - (8, blosc2.Codec.BLOSCLZ), - (9, blosc2.Codec.LZ4), - (3, blosc2.Codec.LZ4HC), - (5, blosc2.Codec.ZLIB), - (2, blosc2.Codec.ZSTD), + (clevel, codec, filt, (codec_index + filter_index) % 2 == 0) + for codec_index, (clevel, codec) in enumerate( + [ + (8, blosc2.Codec.BLOSCLZ), + (9, blosc2.Codec.LZ4), + (3, blosc2.Codec.LZ4HC), + (5, blosc2.Codec.ZLIB), + (2, blosc2.Codec.ZSTD), + ] + ) + for filter_index, filt in enumerate(blosc2.Filter) ], ) -@pytest.mark.parametrize("filt", list(blosc2.Filter)) def test_compressors(clevel, filt, codec, gil): blosc2.set_releasegil(gil) src = b"Something to be compressed" * 100 diff --git a/tests/test_deserialization.py b/tests/test_deserialization.py index 1aae429dd..8e3cba9c8 100644 --- a/tests/test_deserialization.py +++ b/tests/test_deserialization.py @@ -180,13 +180,23 @@ def test_active_top_level_object_requires_full(tmp_path): path = tmp_path / "expression.b2nd" expression.save(path) - with pytest.raises(blosc2.UnsafeDeserializationError, match="lazyexpr"): - blosc2.open(path) + np.testing.assert_array_equal(blosc2.open(path)[:], np.arange(4) + 1) trusted = blosc2.open(path, deserialize="full") np.testing.assert_array_equal(trusted[:], np.arange(4) + 1) +@pytest.mark.parametrize("expression", ["sqrt(x)", "sum(x)", "x.mean()", "x[0]"]) +def test_ordinary_lazyexpr_roundtrip_defaults_safe(tmp_path, expression): + values = np.arange(1, 5, dtype="float64") + operand = blosc2.asarray(values, urlpath=tmp_path / "operand.b2nd", mode="w") + lazy = blosc2.lazyexpr(expression, operands={"x": operand}) + expected = lazy[()] + path = tmp_path / "expression.b2nd" + lazy.save(path) + np.testing.assert_allclose(blosc2.open(path)[()], expected) + + @pytest.mark.parametrize("value", [True, False, "unknown", None]) def test_invalid_deserialize_mode(value): source = blosc2.SChunk() diff --git a/tests/test_dsl_execution.py b/tests/test_dsl_execution.py new file mode 100644 index 000000000..6e96ef198 --- /dev/null +++ b/tests/test_dsl_execution.py @@ -0,0 +1,209 @@ +"""Bindings and dispatch contracts for source-authored Menudet execution.""" + +import importlib +import sys + +import numpy as np +import pytest + +import blosc2 + +pytestmark = pytest.mark.skipif( + not blosc2.blosc2_ext.portable_descriptor_available(), + reason="Portable runtime required", +) + + +@pytest.fixture +def forbid_legacy(monkeypatch): + def forbidden(*args, **kwargs): + pytest.fail("Supported DSL execution entered the legacy evaluator") + + monkeypatch.setattr(blosc2.NDArray, "_set_pref_expr", forbidden) + monkeypatch.setattr(importlib.import_module("blosc2.lazyexpr"), "chunked_eval", forbidden) + + +def test_dsl_udf_compute_slice_and_out(forbid_legacy, tmp_path): + source = blosc2.DSLKernel.from_source("def k(x, bias):\n return x + bias\n") + values = np.arange(48, dtype="float64").reshape(6, 8) + x = blosc2.asarray(values, chunks=(6, 8), blocks=(2, 4)) + lazy = blosc2.lazyudf(source, (x, 3.0), dtype="float64", jit=False) + np.testing.assert_array_equal(lazy[1:5:2, 2:7], (values + 3)[1:5:2, 2:7]) + output = np.empty_like(values) + assert lazy.compute(out=output) is output + np.testing.assert_array_equal(output, values + 3) + result = lazy.compute(urlpath=tmp_path / "output.b2nd", chunks=(3, 4), blocks=(1, 2)) + assert result.chunks == (3, 4) + np.testing.assert_array_equal(result[:], values + 3) + assert lazy._native_execution_report["route"] == "menudet-lazyudf" + + +def test_dsl_input_free_and_jit_wrapper(forbid_legacy): + kernel = blosc2.DSLKernel.from_source("def k(start):\n return start + _flat_idx\n") + lazy = blosc2.lazyudf(kernel, (7,), dtype="int64", shape=(5, 7), jit=False) + np.testing.assert_array_equal(lazy[:], 7 + np.arange(35).reshape(5, 7)) + + @blosc2.jit(jit=False) + def bounded(x, limit=3): + if x > limit: + return limit + return x + + np.testing.assert_array_equal(bounded(np.arange(10.0)), np.minimum(np.arange(10.0), 3)) + + +def test_small_constructors_use_menudet_without_jit(monkeypatch): + def forbidden(*args, **kwargs): + pytest.fail("Supported small ramps must not create a legacy LazyUDF") + + monkeypatch.setattr(blosc2, "lazyudf", forbidden) + original = blosc2.PortableKernel.from_json + observed = [] + + def load(artifact, *, jit=None): + observed.append(jit) + return original(artifact, jit=jit) + + monkeypatch.setattr(blosc2.PortableKernel, "from_json", load) + np.testing.assert_array_equal(blosc2.arange(31)[:], np.arange(31)) + assert observed[-1] is False + np.testing.assert_allclose(blosc2.linspace(0, 1, 31)[:], np.linspace(0, 1, 31)) + assert observed[-1] is False + blosc2.arange(31, jit=True) + assert observed[-1] is (not blosc2.IS_WASM) + + +@pytest.mark.parametrize("scalar_return", [False, True]) +def test_padded_groups_and_scalar_broadcast(forbid_legacy, scalar_return): + values = np.arange(11 * 13, dtype="float64").reshape(11, 13) + x = blosc2.asarray(values, chunks=(6, 8), blocks=(4, 3)) + body = "block_sum(x)" if scalar_return else "x + block_sum(x) + _i0" + kernel = blosc2.DSLKernel.from_source(f"def k(x):\n return {body}\n") + lazy = blosc2.lazyudf(kernel, (x,), dtype="float64", jit=False, in_place=True) + expected = np.empty_like(values) + if scalar_return: + expected = np.array( + [ + [values[r : min(r + 4, 11), c : min(c + 3, 13)].sum() for c in (0, 3, 6, 9, 12)] + for r in (0, 4, 8) + ] + ) + np.testing.assert_array_equal(lazy[:], expected) + return + for row in range(0, 11, 6): + for col in range(0, 13, 8): + for r in range(row, min(row + 6, 11), 4): + for c in range(col, min(col + 8, 13), 3): + item = (slice(r, min(r + 4, row + 6, 11)), slice(c, min(c + 3, col + 8, 13))) + block = values[item] + expected[item] = block + block.sum() + np.arange(r, item[0].stop)[:, None] + np.testing.assert_array_equal(lazy[:], expected) + np.testing.assert_array_equal(lazy[1:10:2, 2:12:3], expected[1:10:2, 2:12:3]) + np.testing.assert_array_equal(lazy.compute(chunks=(5, 5), blocks=(2, 2))[:], expected) + + +def test_portable_loader_options(forbid_legacy, tmp_path, capfd): + if blosc2.IS_WASM or sys.platform == "win32": + pytest.skip("No host compiler backend on WASM/Windows") + if not blosc2.blosc2_ext.portable_artifact_options_available(): + pytest.skip("Requires the native artifact options API") + kernel = blosc2.DSLKernel.from_source("def k(x):\n return x + 1\n") + lazy = blosc2.lazyudf(kernel, (np.arange(31.0),), dtype="float64") + with blosc2.jit_options(jit_backend="cc", compiler="/no/compiler", cache_dir=tmp_path, trace=True): + np.testing.assert_array_equal(lazy[:], np.arange(31.0) + 1) + assert "compiler unavailable" in capfd.readouterr().err + assert lazy._native_execution_report["route"] == "menudet-lazyudf" + assert not lazy._native_execution_report["jit"] + assert not blosc2.get_jit_options()["trace"] + + +@pytest.mark.parametrize("dtype", ["complex64", "complex128"]) +def test_complex_kernels_use_menudet(forbid_legacy, dtype): + z = np.array([1 + 2j, 3 - 4j, -2 + 0.5j, 0 + 0j], dtype=dtype) + kernel = blosc2.DSLKernel.from_source( + "def k(z):\n" + " v = z\n" + " for i in range(2):\n" + " v = v * z\n" + " if imag(v) < 0:\n" + " return v + 1\n" + " return v\n" + ) + lazy = blosc2.lazyudf(kernel, (z,), dtype=dtype, jit=True) + expected = z * z * z + expected = np.where(expected.imag < 0, expected + 1, expected) + np.testing.assert_allclose(lazy[:], expected, rtol=1e-6) + assert lazy._native_execution_report["route"] == "menudet-lazyudf" + # Complex is interpreter-only; requesting JIT must not compile partial code. + assert lazy._native_execution_report["jit"] is False + result = lazy.compute(chunks=(2,), blocks=(1,)) + np.testing.assert_allclose(result[:], expected, rtol=1e-6) + + +def test_complex_real_results_constants_and_reductions(forbid_legacy): + z = np.array([1 + 2j, 3 - 4j, -2 + 0.5j, 0 + 0j], dtype=np.complex128) + real = blosc2.lazyudf( + blosc2.DSLKernel.from_source("def k(z):\n return abs(z) + real(z) - imag(z)\n"), + (z,), + dtype=np.float64, + jit=False, + ) + np.testing.assert_allclose(real[:], np.abs(z) + z.real - z.imag) + shifted = blosc2.lazyudf( + blosc2.DSLKernel.from_source("def k(z, c):\n return z + c\n"), + (z, 2 + 3j), + dtype=z.dtype, + jit=False, + ) + np.testing.assert_allclose(shifted[:], z + (2 + 3j)) + summed = blosc2.lazyudf( + blosc2.DSLKernel.from_source("def k(z):\n return block_sum(z)\n"), + (blosc2.asarray(z, chunks=(4,), blocks=(4,)),), + dtype=z.dtype, + jit=False, + ) + np.testing.assert_allclose(summed[()], [z.sum()]) + + +@pytest.mark.parametrize("dtype", ["complex64", "complex128"]) +@pytest.mark.parametrize("compressed", [False, True]) +@pytest.mark.parametrize("operation", ["real", "conj"]) +def test_complex_callback_identity(forbid_legacy, dtype, compressed, operation): + # Optimized WASM links must keep real and conj distinct despite their + # identical real-valued callbacks in the classic builtin registry. + z = np.array([1 + 2j, 3 - 4j, -2 + 0.5j, 0j], dtype=dtype) + values = blosc2.asarray(z, chunks=(2,), blocks=(1,)) if compressed else z + output_dtype = z.real.dtype if operation == "real" else z.dtype + source = blosc2.DSLKernel.from_source(f"def k(z):\n return {operation}(z)\n") + lazy = blosc2.lazyudf(source, (values,), dtype=output_dtype, jit=False) + expected = z.real if operation == "real" else z.conj() + np.testing.assert_array_equal(lazy[:], expected) + np.testing.assert_array_equal(lazy[1::2], expected[1::2]) + np.testing.assert_array_equal(lazy.compute(chunks=(2,), blocks=(1,))[:], expected) + assert lazy._native_execution_report["route"] == "menudet-lazyudf" + + +def test_complex_comparisons_and_where(forbid_legacy): + z = np.array([1 + 2j, 3 - 4j, -2 + 0.5j, 0 + 0j]) + comparisons = blosc2.lazyudf( + blosc2.DSLKernel.from_source("def k(z):\n return z < z\n"), + (z,), + dtype=bool, + jit=False, + ) + np.testing.assert_array_equal(comparisons[:], z < z) + selected = blosc2.lazyudf( + blosc2.DSLKernel.from_source("def k(z):\n return where(z, 1.0, 2.0)\n"), + (z,), + dtype=np.float64, + jit=False, + ) + np.testing.assert_array_equal(selected[:], np.where(z, 1.0, 2.0)) + + +@pytest.mark.parametrize("unsupported", ["z // 2", "ceil(z)", "float(z)"]) +def test_complex_unsupported_operations_raise(forbid_legacy, unsupported): + kernel = blosc2.DSLKernel.from_source(f"def k(z):\n return {unsupported}\n") + lazy = blosc2.lazyudf(kernel, (np.array([1 + 2j]),), dtype=np.complex128, jit=False) + with pytest.raises(RuntimeError, match="Menudet compilation failed"): + lazy[:] diff --git a/tests/test_dsl_portable.py b/tests/test_dsl_portable.py new file mode 100644 index 000000000..20e2c79a7 --- /dev/null +++ b/tests/test_dsl_portable.py @@ -0,0 +1,384 @@ +"""Representative Python host conformance; exhaustive fixtures belong to miniexpr.""" + +import json +import os +import subprocess +from pathlib import Path + +import numpy as np +import pytest + +import blosc2 +from blosc2.dsl_kernel import DSLKernel + +# External conformance is opt-in; never infer an unrelated sibling checkout. +# Selected historical fixtures also cover behavior shared by public Menudet 1.0. +CORPUS = Path(os.environ["MINIEXPR_PORTABLE_CORPUS"]) if os.environ.get("MINIEXPR_PORTABLE_CORPUS") else None + + +# Native CTest runs every fixture under its supported execution engines. Python +# tests only distinct host boundaries here and representative output conversions; +# numerical/JIT scenarios are covered separately by test_portable_artifact.py. +CASES = [ + "affine", + "special_floats", + "math", + "division_bool", + "division_locals", + "while_cap_exceeded", + "unknown_name", + "zero_step", + "missing_return_mixed", + "missing_return_loop", + "missing_return_loop_ok", +] +TYPES = ("bool", "int32", "int64", "float32", "float64") +CASES += [ + f"convert_{input_type}_{output_type}" + for input_type, output_type in ( + ("bool", "int64"), + ("int32", "bool"), + ("int64", "float32"), + ("float32", "float64"), + ("float64", "int32"), + ) +] + + +def corpus_source(case): + return CORPUS / ("identity.dsl" if case.startswith("convert_") else f"{case}.dsl") + + +def typed_values(values, dtype): + # NumPy treats nonempty strings as True; fixture Boolean tokens are 0/1. + return np.array([int(value) for value in values] if dtype == np.dtype("bool") else values, dtype=dtype) + + +def assert_typed_result(actual, expected, *, exact=False): + assert actual.dtype == expected.dtype + if expected.dtype.kind in "biu" or exact: + np.testing.assert_array_equal(actual, expected) + if expected.dtype.kind == "f": + if not exact: + tolerance = 1e-6 if expected.dtype == np.dtype("float32") else 1e-12 + np.testing.assert_allclose(actual, expected, rtol=tolerance, atol=tolerance, equal_nan=True) + zeros = expected == 0 + np.testing.assert_array_equal(np.signbit(actual[zeros]), np.signbit(expected[zeros])) + + +@pytest.mark.parametrize("case", CASES) +def test_native_source_corpus(case, portable_validator, monkeypatch): + if case.startswith("while_cap_"): + monkeypatch.setenv("ME_DSL_WHILE_MAX_ITERS", "3") + if CORPUS is None: + pytest.skip("Set MINIEXPR_PORTABLE_CORPUS to the native miniexpr fixture directory") + # These selected cases share their values with the historical checked corpus. + source = corpus_source(case).read_text() + words = (CORPUS / f"{case}.txt").read_text().split() + outcome, input_type, output_type = words[:3] + count, nvars = map(int, words[3:5]) + names = words[5 : 5 + nvars] + info = portable_validator(source, dict.fromkeys(names, input_type), output_type) + assert info["valid"] == (outcome != "compile_error"), info + rows = np.array(words[5 + nvars :]).reshape(count, nvars + 1) + input_dtype, output_dtype = np.dtype(input_type), np.dtype(output_type) + expected = typed_values(rows[:, -1], output_dtype) + kernel = DSLKernel.from_source(source) + by_name = {name: typed_values(rows[:, index], input_dtype) for index, name in enumerate(names)} + if outcome in {"ok", "ok_exact"}: + artifact = kernel.export(dict.fromkeys(names, input_type), output_type) + loaded = blosc2.PortableKernel.from_json(artifact, jit=False) + assert not loaded.has_jit + result = loaded.evaluate(by_name) + assert_typed_result(result, expected, exact=outcome == "ok_exact") + elif outcome == "compile_error": + with pytest.raises(blosc2.PortableArtifactError): + kernel.export(dict.fromkeys(names, input_type), output_type) + else: + artifact = kernel.export(dict.fromkeys(names, input_type), output_type) + loaded = blosc2.PortableKernel.from_json(artifact, jit=False) + with pytest.raises(blosc2.PortableArtifactError, match="evaluation_error"): + loaded.evaluate(by_name) + assert kernel.dsl_source == source + assert kernel.func is None + + runner = os.environ.get("MINIEXPR_PORTABLE_RUNNER") + if runner: + completed = subprocess.run( + [ + runner, + str(corpus_source(case)), + str(CORPUS / f"{case}.txt"), + "on", + ], + check=True, + capture_output=True, + text=True, + ) + lines = completed.stdout.splitlines() + if outcome == "compile_error": + assert lines == [outcome] + else: + assert lines[0] == "jit=0" + if outcome == "eval_error": + assert lines[1:] == [outcome] + else: + assert_typed_result( + typed_values(lines[1:], output_dtype), expected, exact=outcome == "ok_exact" + ) + + +def test_from_source_never_executes_python(tmp_path): + target = tmp_path / "executed" + with pytest.raises(ValueError, match="start with a function"): + DSLKernel.from_source(f"open({str(target)!r}, 'w')\ndef kernel(x):\n return x\n") + with pytest.raises(ValueError, match="plain positional"): + DSLKernel.from_source(f"def kernel(x=open({str(target)!r}, 'w')):\n return x\n") + assert not target.exists() + + +@pytest.mark.parametrize( + "source", ["", "def broken(", "def k(x, x):\n return x", "def k(x):\n return x\x00"] +) +def test_from_source_invalid_header(source): + with pytest.raises(ValueError): + DSLKernel.from_source(source) + + +def test_from_source_native_body_and_no_python_fallback(): + source = "# me:compiler=tcc\ndef kernel(x):\n return !x\n" + kernel = DSLKernel.from_source(source) + assert kernel.dsl_source == source + assert kernel.input_names == ["x"] + with pytest.raises(RuntimeError, match="cannot execute as a Python"): + kernel((np.array([1.0]),), np.empty(1)) + + +@pytest.mark.parametrize("jit", [False, True]) +def test_from_source_without_external_corpus(jit): + source = "# me:compiler=tcc\ndef kernel(x):\n return !x\n" + kernel = blosc2.DSLKernel.from_source(source) + result = blosc2.lazyudf(kernel, (np.array([0.0, 1.0, -1.0]),), dtype=np.bool_, jit=jit)[:] + np.testing.assert_array_equal(result, [True, False, False]) + + +def test_from_source_invalid_native_body(): + kernel = DSLKernel.from_source("def kernel(x):\n return x[0]\n") + with pytest.raises((NotImplementedError, RuntimeError)): + blosc2.lazyudf(kernel, (np.arange(4, dtype=np.float64),), dtype=np.float64)[:] + + +@pytest.fixture +def portable_validator(): + info = blosc2.validate_portable_dsl("def k(x):\n return x\n", {"x": "float64"}, "float64") + if info["status"] == "runtime_unsupported": + pytest.skip("Rebuild with miniexpr portable validation support") + assert info == {"valid": True, "status": "success", "line": 0, "column": 0, "error": None} + return blosc2.validate_portable_dsl + + +@pytest.mark.parametrize( + ("body", "status"), + [ + ("print(x); return x", "invalid_source"), + ("return np.sin(x)", "invalid_source"), + ("return x.lower()", "invalid_source"), + ("return x[0]", "invalid_source"), + ("return _flat_idx + x", "invalid_source"), + ("return callback(x)", "invalid_source"), + ("return CAPTURE + x", "invalid_source"), + ("return sin()", "invalid_source"), + ], +) +def test_portable_profile_rejections(portable_validator, body, status): + info = portable_validator(f"def k(x):\n {body}\n", {"x": "float64"}, "float64") + assert not info["valid"] + assert info["status"] == status + assert info["error"] + if "_flat_idx" in body: + # Descriptor-wide missing-context diagnostic is not a source location. + assert info["line"] == 0 + else: + assert info["line"] == 2 + assert info["column"] > 0 + + +def test_portable_profile_signature_and_version(portable_validator): + source = "def k(x, y):\n return x + y\n" + inputs = {"y": "float64", "x": "float64"} + assert portable_validator(source, inputs, "float64")["valid"] + assert portable_validator(source, inputs, "float64", language_version="99")["status"] == ( + "unsupported_version" + ) + assert portable_validator(source, {"x": "float64"}, "float64")["status"] == "invalid_signature" + assert portable_validator(source, {"x": "float64", "y": "int32"}, "float64")["valid"] + assert ( + portable_validator(source, inputs, "float64", language_version="0.1")["status"] + == "unsupported_version" + ) + assert portable_validator(source, inputs, "complex128")["status"] == "success" + + +def test_portable_profile_never_executes_or_compiles_jit(portable_validator, monkeypatch, tmp_path): + cache = tmp_path / "jit-cache" + target = tmp_path / "executed" + monkeypatch.setenv("CC", "/no/compiler") + monkeypatch.setenv("ME_DSL_JIT_COMPILER", "cc") + monkeypatch.setenv("ME_DSL_JIT", "1") + monkeypatch.setenv("ME_DSL_FP_MODE", "fast") + monkeypatch.setenv("ME_DSL_JIT_CACHE_DIR", str(cache)) + # This would reach the iteration cap if executed. Validation must still succeed. + source = "# me:compiler=cc\ndef k(x):\n while 1:\n pass\n return x\n" + assert portable_validator(source, {"x": "float64"}, "float64")["valid"] + source = f"def k(x):\n return open({str(target)!r}, 'w')\n" + assert not portable_validator(source, {"x": "float64"}, "float64")["valid"] + assert not target.exists() + assert not cache.exists() + + +def test_portable_profile_missing_native_support(monkeypatch): + from blosc2 import blosc2_ext + + monkeypatch.delattr(blosc2_ext, "validate_portable_dsl_source", raising=False) + info = blosc2.validate_portable_dsl("def k(x):\n return x\n", {"x": "float64"}, "float64") + assert not info["valid"] + assert info["status"] == "runtime_unsupported" + + +@pytest.mark.parametrize( + ("source", "inputs", "version"), + [ + ("def k(x):\n return x\n\x00", {"x": "float64"}, "1.0"), + ("def k(x):\n return x\n", {"x\x00": "float64"}, "1.0"), + ("def k(x):\n return x\n", {"x": "float64"}, "1.0\x00"), + ], +) +def test_portable_profile_rejects_nul(source, inputs, version): + with pytest.raises(ValueError, match="NUL"): + blosc2.validate_portable_dsl(source, inputs, "float64", language_version=version) + + +@pytest.mark.parametrize("literal", ["9007199254740993", "9_007_199_254_740_993", "0x20000000000001"]) +def test_portable_integer_literal_bound_is_exact(portable_validator, literal): + info = portable_validator(f"def k(x):\n return x + {literal}\n", {"x": "int64"}, "int64") + assert info["valid"], info + author = DSLKernel.from_source(f"def k(x):\n return x + {literal}\n") + kernel = blosc2.PortableKernel.from_json(author.export({"x": "int64"}, "int64")) + np.testing.assert_array_equal( + kernel.evaluate({"x": np.array([0, 1], dtype="int64")}), [2**53 + 1, 2**53 + 2] + ) + with np.errstate(over="ignore"): + np.testing.assert_array_equal( + kernel.evaluate({"x": np.array([np.iinfo("int64").max], dtype="int64")}), + np.array([np.iinfo("int64").max], dtype="int64") + (2**53 + 1), + ) + + +def test_portable_export_preserves_math_policy(): + source = "# me:math=sleef\n# me:ulp=u35\n# me:compiler=cc\ndef k(x):\n return sin(x) + cos(x)\n" + kernel = DSLKernel.from_source(source) + try: + artifact = kernel.export({"x": "float64"}, "float64") + except blosc2.PortableArtifactError as error: + pytest.skip(f"SLEEF unavailable on this host: {error}") + manifest = json.loads(artifact) + assert manifest["semantics"]["math"] == "sleef" + assert manifest["semantics"]["ulp"] == "u35" + assert "flexible-math" in manifest["requires"] + loaded = blosc2.PortableKernel.from_json(artifact, jit=False) + assert loaded._info["math_backend"] == "sleef" + assert loaded._info["sleef_accuracy"] == "u35" + x = np.linspace(-2, 2, 257) + result = loaded.evaluate({"x": x}) + np.testing.assert_allclose(result, np.sin(x) + np.cos(x), rtol=1e-6, atol=1e-6) + + +def test_portable_export_fast_requires_cc_and_round_trips(monkeypatch): + source = "# me:fp=fast\ndef k(x):\n return sin(x) + 1\n" + kernel = DSLKernel.from_source(source) + with pytest.raises(blosc2.PortableArtifactError, match="TCC"): + kernel.export({"x": "float64"}, "float64") + + monkeypatch.setenv("ME_DSL_JIT_COMPILER", "cc") + inherited = kernel.export({"x": "float64"}, "float64") + assert blosc2.PortableKernel.from_json(inherited, jit=False)._info["fp_mode"] == "fast" + + source = "# me:compiler=cc\n# me:fp=fast\ndef k(x):\n return sin(x) + 1\n" + kernel = DSLKernel.from_source(source) + artifact = kernel.export({"x": "float64"}, "float64") + manifest = json.loads(artifact) + assert manifest["semantics"]["fp"] == "fast" + assert "flexible-math" in manifest["requires"] + loaded = blosc2.PortableKernel.from_json(artifact, jit=False) + assert loaded._info["fp_mode"] == "fast" + + +def test_portable_artifact_math_policy_conflict_and_capability(): + source = "# me:math=system\ndef k(x):\n return sin(x)\n" + manifest = json.loads(DSLKernel.from_source(source).export({"x": "float64"}, "float64")) + manifest["semantics"]["math"] = "sleef" + with pytest.raises(blosc2.PortableArtifactError, match="conflict"): + blosc2.PortableKernel.from_json(json.dumps(manifest), jit=False) + manifest["source"] = "# me:math=sleef\n# me:compiler=cc\ndef k(x):\n return sin(x)\n" + manifest["requires"].remove("flexible-math") + with pytest.raises(blosc2.PortableArtifactError, match="flexible-math"): + blosc2.PortableKernel.from_json(json.dumps(manifest), jit=False) + + manifest["semantics"].pop("math") + manifest["source"] = source + with pytest.raises(blosc2.PortableArtifactError, match="flexible-math"): + blosc2.PortableKernel.from_json(json.dumps(manifest), jit=False) + + +def test_portable_math_environment_inheritance_and_source_override(monkeypatch): + plain = "def k(x):\n return sin(x)\n" + manifest = json.loads(DSLKernel.from_source(plain).export({"x": "float64"}, "float64")) + assert "math" not in manifest["semantics"] + assert "flexible-math" not in manifest["requires"] + monkeypatch.setenv("ME_SIMD_MATH_BACKEND", "sleef") + try: + loaded = blosc2.PortableKernel.from_json(json.dumps(manifest), jit=False) + except blosc2.PortableArtifactError as error: + if "unavailable" in str(error): + pytest.skip(f"SLEEF unavailable on this host: {error}") + raise + assert loaded._info["math_backend"] == "sleef" + assert loaded._info["sleef_accuracy"] == "u35" + + source = "# me:math=system\ndef k(x):\n return sin(x)\n" + explicit = json.loads(DSLKernel.from_source(source).export({"x": "float64"}, "float64")) + loaded = blosc2.PortableKernel.from_json(json.dumps(explicit), jit=False) + assert loaded._info["math_backend"] == "system" + + +def test_portable_concurrent_math_backends_are_kernel_local(): + from concurrent.futures import ThreadPoolExecutor + + x = np.linspace(-2, 2, 200_003) + reference = np.sin(x) + np.cos(x) + system = blosc2.PortableKernel.from_json( + DSLKernel.from_source("# me:math=system\ndef k(x):\n return sin(x) + cos(x)\n").export( + {"x": "float64"}, "float64" + ), + jit=False, + ) + try: + sleef = blosc2.PortableKernel.from_json( + DSLKernel.from_source( + "# me:math=sleef\n# me:ulp=u35\ndef k(x):\n return sin(x) + cos(x)\n" + ).export({"x": "float64"}, "float64"), + jit=False, + ) + except blosc2.PortableArtifactError as error: + if "unavailable" in str(error): + pytest.skip(f"SLEEF unavailable on this host: {error}") + raise + kernels = [system, sleef] * 4 + + def run(kernel): + return kernel.evaluate({"x": x}) + + with ThreadPoolExecutor(max_workers=8) as pool: + results = list(pool.map(run, kernels)) + for result in results: + np.testing.assert_allclose(result, reference, rtol=1e-6, atol=1e-6) diff --git a/tests/test_dsl_scalar_dispatch.py b/tests/test_dsl_scalar_dispatch.py new file mode 100644 index 000000000..a006d2a75 --- /dev/null +++ b/tests/test_dsl_scalar_dispatch.py @@ -0,0 +1,156 @@ +"""Single-return scalar execution preserves the general DSL interpreter contract.""" + +import sys +from concurrent.futures import ThreadPoolExecutor + +import numpy as np +import pytest + +import blosc2 + +pytestmark = pytest.mark.usefixtures("native_graph_runtime") + + +def scalar_kernel(body, inputs, output="float64", *, jit=False, ndim=0, cardinality="block_scalar"): + arguments = ", ".join(inputs) + artifact = blosc2.DSLKernel.from_source(f"def k({arguments}):\n {body}\n").export( + inputs, output, version="1.0", cardinality=cardinality, ndim=ndim + ) + return blosc2.PortableKernel.from_json(artifact, jit=jit) + + +@pytest.mark.parametrize(("jit", "dtype"), [(False, "float32"), (True, "float64"), (True, "int64")]) +@pytest.mark.parametrize( + "expression", + [ + "block_sum(x + y)", + "block_sum(x) + block_sum(y)", + "block_sum(x) + block_sum(x)", + "block_sum(x) / 2", + "block_mean(x)", + "block_sum(x) > block_sum(y)", + ], +) +def test_simple_scalar_expression_matches_statement_path(dtype, expression, jit): + output = ( + "bool" + if ">" in expression + else "float64" + if dtype == "int64" and ("/" in expression or expression.startswith("block_mean")) + else dtype + ) + signature = {"x": dtype, "y": dtype} + direct = scalar_kernel(f"return {expression}", signature, output, jit=jit) + general = scalar_kernel(f"s = {expression}\n return s", signature, output, jit=jit) + x = np.array([1, -2, 3, 4], dtype=dtype) + y = np.array([2, 1, -1, 0], dtype=dtype) + inputs = {"y": y, "x": x} # Runtime binding order is not expression variable order. + for mask in ( + None, + np.ones(4, dtype=bool), + np.array([False, True, True, False]), + np.zeros(4, dtype=bool), + ): + actual, status = direct.evaluate_block(inputs, valid_mask=mask, return_status=True) + expected, reference = general.evaluate_block(inputs, valid_mask=mask, return_status=True) + assert actual.dtype == expected.dtype + assert actual.tobytes() == expected.tobytes() + assert status == reference + empty = {name: np.empty(0, dtype=dtype) for name in signature} + actual, status = direct.evaluate_block(empty, return_status=True) + expected, reference = general.evaluate_block(empty, return_status=True) + assert actual.tobytes() == expected.tobytes() + assert status == reference + + +@pytest.mark.parametrize("output", ["float32", "float64", "int64"]) +def test_simple_scalar_output_conversion(output): + signature = {"x": "int64"} + direct = scalar_kernel("return block_sum(x)", signature, output) + general = scalar_kernel("s = block_sum(x)\n return s", signature, output) + inputs = {"x": np.array([1, 2, 3], dtype="int64")} + actual = direct.evaluate_block(inputs) + assert actual.dtype == np.dtype(output) + assert actual.tobytes() == general.evaluate_block(inputs).tobytes() + + +def test_simple_scalar_errors_are_not_retried_or_cached(): + kernel = scalar_kernel("return block_sum(x)", {"x": "int64"}, "int64") + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block({"x": np.array([2**63 - 1, 1], dtype="int64")}) + assert kernel.evaluate_block({"x": np.array([1, 2], dtype="int64")}) == 3 + for inputs in ( + {}, + {"x": np.array([1], dtype="float64")}, + {"x": np.array([1], dtype="int64"), "y": np.array([1])}, + ): + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block(inputs) + + +def test_simple_scalar_fp_errors_and_inactive_lanes(): + kernel = scalar_kernel("return block_prod(x)", {"x": "float64"}) + x = np.array([np.inf, 0, 2], dtype="float64") + actual, status = kernel.evaluate_block({"x": x}, return_status=True) + assert np.isnan(actual) + if sys.platform == "emscripten": + assert status == {"supported": False, "flags": 0} + error = "unsupported" + else: + assert status["supported"] + assert status["flags"] & 1 + error = "floating" + with pytest.raises(blosc2.PortableArtifactError, match=error): + kernel.evaluate_block({"x": x}, fp_errors="raise") + actual, status = kernel.evaluate_block( + {"x": x}, + valid_mask=np.array([False, False, True]), + return_status=True, + fp_errors="ignore" if sys.platform == "emscripten" else "raise", + ) + assert actual == 2 + assert status["flags"] == 0 + + +def test_simple_scalar_context_and_elementwise_fallback(): + context = scalar_kernel("return block_sum(_flat_idx)", {}, "int64", ndim=1) + assert context.evaluate_block({}, block_shape=(3,), logical_shape=(8,), block_origin=(2,)) == 9 + with pytest.raises((ValueError, blosc2.PortableArtifactError)): + context.evaluate_block({}, block_shape=(3,)) + elementwise = scalar_kernel("return x * 2", {"x": "float64"}, cardinality="elementwise") + x = np.array([1, 2, 3], dtype="float64") + np.testing.assert_array_equal(elementwise.evaluate_block({"x": x}), x * 2) + + +def test_simple_scalar_statement_control_flow_fallback(): + kernel = scalar_kernel( + "s = block_sum(x)\n if s > 0:\n return s + 1\n return s - 1", {"x": "int64"}, "int64" + ) + assert kernel.evaluate_block({"x": np.array([1, 2], dtype="int64")}) == 4 + assert kernel.evaluate_block({"x": np.array([-1, -2], dtype="int64")}) == -4 + uninitialized = scalar_kernel( + "if block_all(x > 0):\n s = 3\n return s", + {"x": "int64"}, + "int64", + cardinality="elementwise", + ) + np.testing.assert_array_equal( + uninitialized.evaluate_block({"x": np.array([1, 2], dtype="int64")}), [3, 3] + ) + with pytest.raises(blosc2.PortableArtifactError): + uninitialized.evaluate_block({"x": np.array([-1, 2], dtype="int64")}) + + +def test_simple_scalar_concurrent_reuse(): + kernel = scalar_kernel("return block_sum(x) + block_sum(x)", {"x": "float64"}) + + def evaluate(value): + return kernel.evaluate_block({"x": np.full(1024, value, dtype="float64")}) + + if sys.platform == "emscripten": + # Single-threaded Pyodide still checks repeated immutable-handle reuse. + results = list(map(evaluate, range(16))) + else: + with ThreadPoolExecutor(max_workers=4) as pool: + results = list(pool.map(evaluate, range(16))) + np.testing.assert_array_equal(results, np.arange(16) * 2048) diff --git a/tests/test_evaluate_menudet_routes.py b/tests/test_evaluate_menudet_routes.py new file mode 100644 index 000000000..0c5cf50f8 --- /dev/null +++ b/tests/test_evaluate_menudet_routes.py @@ -0,0 +1,91 @@ +"""Public evaluate dispatch/output contracts, not native numerical cross-products.""" + +import numpy as np +import pytest + +import blosc2 + + +@pytest.fixture(autouse=True) +def execution_threads(native_graph_runtime): + if blosc2.IS_WASM: + pytest.skip("These automatic map routes require host JIT/thread/prefilter support") + probe = blosc2.NativeGraph.from_expression("x + 1", {"x": "float64"}, jit=True) + if not probe.has_jit: + pytest.skip("Automatic native map dispatch requires an available graph JIT") + # Compressed-input NumPy maps need at least two workers. Do not inherit a + # single-thread setting left by another test in the same xdist worker. + previous = blosc2.set_nthreads(2) + try: + yield + finally: + blosc2.set_nthreads(previous) + + +@pytest.mark.parametrize("inputs", ["numpy", "blosc2", "mixed"]) +@pytest.mark.parametrize("output", ["new", "numpy", "blosc2"]) +@pytest.mark.parametrize("recipe", ["integer", "math"]) +def test_evaluate_native_array_routes(inputs, output, recipe, native_graph_runtime, monkeypatch): + import blosc2.native_graph as native + + monkeypatch.setattr(native, "MINIMUM_COMPRESSED_MAP_ITEMS", 1) + monkeypatch.setattr(native, "MINIMUM_COMPRESSED_GRAPH_ITEMS", 1) + monkeypatch.setattr("blosc2.resident_execution.MINIMUM_WORKER_ITEMS", 64) + dtype = "int64" if recipe == "integer" else "float64" + x = np.arange(1027, dtype=dtype) % 3 + 1 + y = np.ones_like(x) + expression = "((x + y) * 2 - y) * 3 + x * 2 - y" if recipe == "integer" else "sin(x) + cos(y) + 1" + expected = ((x + y) * 2 - y) * 3 + x * 2 - y if recipe == "integer" else np.sin(x) + np.cos(y) + 1 + operands = {"x": x, "y": y} + for key in operands: + if inputs == "blosc2" or (inputs == "mixed" and key == "x"): + operands[key] = blosc2.asarray(operands[key], chunks=(512,), blocks=(128,)) + destination = None if output == "new" else np.empty_like(x) + if output == "blosc2": + destination = blosc2.empty(x.shape, dtype=x.dtype, chunks=(512,), blocks=(128,)) + + def forbidden(*args, **kwargs): + pytest.fail("Eligible evaluate expression fell back to legacy numerical execution") + + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + result = blosc2.evaluate(expression, local_dict=operands, out=destination) + if destination is not None: + assert result is destination + np.testing.assert_allclose( + result[:] if isinstance(result, blosc2.NDArray) else result, expected, rtol=2e-12, atol=2e-12 + ) + # Current operands must be rebound, not retained as cached values. + operands["x"][:] = 2 + result = blosc2.evaluate(expression, local_dict=operands, out=destination) + expected = ((2 + y) * 2 - y) * 3 + 4 - y if recipe == "integer" else np.sin(2) + np.cos(y) + 1 + np.testing.assert_allclose( + result[:] if isinstance(result, blosc2.NDArray) else result, expected, rtol=2e-12, atol=2e-12 + ) + + +def test_evaluate_stored_multidimensional_broadcast(native_graph_runtime, monkeypatch): + x = np.arange(51, dtype="int64").reshape(3, 17) + y = np.arange(17, dtype="int64").reshape(1, 17) + stored = blosc2.asarray(x, chunks=(2, 8), blocks=(1, 4)) + output = blosc2.empty(x.shape, dtype="int64", chunks=(2, 8), blocks=(1, 4)) + + def forbidden(*args, **kwargs): + pytest.fail("Stored native map fell back to legacy") + + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + result = blosc2.evaluate("x + y * 2", local_dict={"x": stored, "y": y}, out=output) + assert result is output + np.testing.assert_array_equal(output[:], x + y * 2) + + +@pytest.mark.parametrize("expression", ["x / y", "x // y", "x % y", "x ** y", "x << y", "x >> y"]) +def test_evaluate_native_integer_operators(expression, native_graph_runtime, monkeypatch): + x = np.array([-9, -1, 0, 1, 9], dtype="int64") + y = np.full_like(x, 2) + + def forbidden(*args, **kwargs): + pytest.fail("Numeric operator did not reach native lowering") + + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + result = blosc2.evaluate(expression, local_dict={"x": x, "y": y}) + np.testing.assert_array_equal(result, eval(expression, {"x": x, "y": y})) diff --git a/tests/test_evaluate_numpy_compat.py b/tests/test_evaluate_numpy_compat.py new file mode 100644 index 000000000..25d631cd5 --- /dev/null +++ b/tests/test_evaluate_numpy_compat.py @@ -0,0 +1,268 @@ +"""NumExpr API compatibility for resident inputs and an explicit NumPy output. + +Numerical/backend cross-products belong in miniexpr. These representative +cases exercise missing expression forms, shape contracts and output policies. +""" + +import numpy as np +import pytest + +import blosc2 + + +@pytest.mark.parametrize("shape", [(0,), (2, 0, 3)]) +@pytest.mark.parametrize("expression", ["x", "x + 1", "copy(x)", "ones_like(x)", "where(x > 0, x, -x)"]) +def test_empty_destination_identity(shape, expression): + x = np.empty(shape) + output = np.empty(shape) + assert blosc2.evaluate(expression, local_dict={"x": x}, out=output) is output + + +@pytest.mark.parametrize("order", ["C", "F", "A", "K"]) +@pytest.mark.parametrize("layout", ["C", "F", "permuted"]) +def test_numpy_output_order(order, layout): + x = np.arange(24.0).reshape(2, 3, 4) + if layout == "F": + x = np.asfortranarray(x) + elif layout == "permuted": + x = x.transpose(1, 2, 0) + expected = np.add(x, 1, order=order) + result = blosc2.evaluate("x + 1", local_dict={"x": x}, order=order) + np.testing.assert_array_equal(result, expected) + assert result.strides == expected.strides + assert not np.shares_memory(result, x) + + +def test_default_order_preserves_fortran_layout(): + x = np.asfortranarray(np.arange(12.0).reshape(3, 4)) + result = blosc2.evaluate("x + 1", local_dict={"x": x}) + assert result.flags.f_contiguous + np.testing.assert_array_equal(result, x + 1) + + +@pytest.mark.parametrize("mode", ["full", "safe"]) +@pytest.mark.parametrize("order", ["C", "F", "A", "K"]) +def test_layout_does_not_select_numexpr(mode, order, monkeypatch): + import importlib + + module = importlib.import_module("blosc2.lazyexpr") + x = np.asfortranarray(np.arange(24.0).reshape(2, 3, 4)) + + def forbidden(*args, **kwargs): + pytest.fail("Output order selected the NumExpr backend") + + if module.numexpr is not None: + for name in ("evaluate", "validate", "NumExpr"): + monkeypatch.setattr(module.numexpr, name, forbidden) + with blosc2.expression_evaluation(mode): + result = blosc2.evaluate("x + 1", local_dict={"x": x}, order=order) + expected = np.add(x, 1, order=order) + np.testing.assert_array_equal(result, expected) + assert result.strides == expected.strides + + +def test_explicit_c_order_retains_native_admission(monkeypatch, native_graph_runtime): + import blosc2.native_graph as native + + if blosc2.IS_WASM: + pytest.skip("Native-first dispatch requires host JIT") + probe = blosc2.NativeGraph.from_expression("x + 1", {"x": "float64"}, jit=True) + if not probe.has_jit: + pytest.skip("Native-first dispatch requires JIT") + original = native.prepare_resident + calls = [] + + def record(*args, **kwargs): + result = original(*args, **kwargs) + if result is not None: + calls.append(True) + return result + + monkeypatch.setattr(native, "prepare_resident", record) + x = np.arange(24.0).reshape(2, 3, 4) + result = blosc2.evaluate("x + 1", local_dict={"x": x}, order="C") + np.testing.assert_array_equal(result, x + 1) + assert calls + + +@pytest.mark.parametrize("order", ["C", "F", "A", "K"]) +def test_broadcast_output_order(order): + x = np.asfortranarray(np.arange(12.0).reshape(3, 4)) + y = np.arange(3.0).reshape(3, 1) + expected = np.add(x, y, order=order) + result = blosc2.evaluate("x + y", local_dict={"x": x, "y": y}, order=order) + np.testing.assert_array_equal(result, expected) + assert result.strides == expected.strides + + +def test_fortran_reduction_and_explicit_destination(): + x = np.arange(24.0).reshape(2, 3, 4) + result = blosc2.evaluate("sum(x, axis=0)", local_dict={"x": x}, order="F") + assert result.flags.f_contiguous + np.testing.assert_array_equal(result, x.sum(axis=0)) + output = np.empty_like(x, order="C") + assert blosc2.evaluate("x + 1", local_dict={"x": x}, out=output, order="F") is output + assert output.flags.c_contiguous + np.testing.assert_array_equal(output, x + 1) + + +def test_order_with_nonbroadcastable_reduction_inputs(): + x = np.arange(12.0).reshape(3, 4) + y = np.arange(10.0).reshape(2, 5) + result = blosc2.evaluate("sum(x) + y", local_dict={"x": x, "y": y}, order="F") + assert result.flags.f_contiguous + np.testing.assert_array_equal(result, x.sum() + y) + + +@pytest.mark.parametrize("mode", ["full", "safe"]) +@pytest.mark.parametrize("option", ["truediv", "sanitize", "disable_cache"]) +def test_removed_options_rejected_before_preparation(mode, option, monkeypatch): + import importlib + + module = importlib.import_module("blosc2.lazyexpr") + + def prepare(*args, **kwargs): + pytest.fail("Removed options must fail before preparing an expression") + + monkeypatch.setattr(module, "lazyexpr", prepare) + x = np.arange(17.0) + output = np.full_like(x, -999) + with blosc2.expression_evaluation(mode): + with pytest.raises(ValueError, match=option): + blosc2.evaluate("x + 1", local_dict={"x": x}, out=output, **{option: True}) + np.testing.assert_array_equal(output, -999) + + +@pytest.mark.parametrize("order", ["invalid", "", None, 1]) +def test_invalid_output_order(order): + x = np.arange(12.0) + with pytest.raises(ValueError, match="order"): + blosc2.evaluate("x + 1", local_dict={"x": x}, order=order) + + +@pytest.fixture +def numexpr(): + return pytest.importorskip("numexpr") + + +@pytest.mark.parametrize("mode", ["full", "safe"]) +@pytest.mark.parametrize( + "expression", + [ + "copy(x)", + "fmod(x, y)", + "where(x > 0.3, x, y)", + "complex(x, y)", + "sum(x)", + "prod(x)", + "min(x)", + "max(x)", + "3.0", + "sin(0.5)", + ], +) +def test_numexpr_expression_forms(numexpr, mode, expression): + inputs = {"x": np.linspace(0.1, 0.6, 17), "y": np.linspace(1.1, 1.6, 17)} + expected = numexpr.evaluate(expression, local_dict=inputs) + output = np.empty_like(expected) + with blosc2.expression_evaluation(mode): + result = blosc2.evaluate(expression, local_dict=inputs, out=output) + assert result is output + np.testing.assert_allclose(result, expected, rtol=1e-12, atol=1e-12) + + +@pytest.mark.parametrize("casting", ["no", "safe", "same_kind", "unsafe"]) +def test_numexpr_output_casting(numexpr, casting): + inputs = {"x": np.arange(17.0), "y": np.ones(17)} + output = np.full(17, -999, dtype="float32") + if casting in {"no", "safe"}: + with pytest.raises(TypeError): + numexpr.evaluate("x + y", local_dict=inputs, out=output, casting=casting) + with pytest.raises(TypeError): + blosc2.evaluate("x + y", local_dict=inputs, out=output, casting=casting) + np.testing.assert_array_equal(output, -999) + else: + assert blosc2.evaluate("x + y", local_dict=inputs, out=output, casting=casting) is output + np.testing.assert_array_equal(output, inputs["x"] + inputs["y"]) + + +def test_complex_constructor_preserves_infinite_components(): + real = np.array([1.0, np.inf, -np.inf]) + imag = np.array([np.inf, 2.0, -np.inf]) + output = np.empty(3, dtype="complex128") + with np.errstate(all="raise"): + result = blosc2.evaluate("complex(x, y)", local_dict={"x": real, "y": imag}, out=output) + assert result is output + np.testing.assert_array_equal(result.real, real) + np.testing.assert_array_equal(result.imag, imag) + + +def test_output_cache_does_not_retain_destination(monkeypatch): + import gc + import importlib + import weakref + + module = importlib.import_module("blosc2.lazyexpr") + module._evaluate_recipe_cache.clear() + x = np.arange(17.0) + output = np.empty_like(x) + reference = weakref.ref(output) + assert blosc2.evaluate("x + 1", local_dict={"x": x}, out=output) is output + assert module._evaluate_recipe_cache + del output + gc.collect() + assert reference() is None + + def forbidden(*args, **kwargs): + pytest.fail("Cached explicit-output evaluation rebuilt its LazyExpr") + + monkeypatch.setattr(blosc2.LazyExpr, "_new_expr", forbidden) + rebound = np.arange(17.0) + 10 + output = np.empty_like(rebound) + assert blosc2.evaluate("x + 1", local_dict={"x": rebound}, out=output) is output + np.testing.assert_array_equal(output, rebound + 1) + + +@pytest.mark.parametrize("expression", ["sqrt(x * x)", "hypot(x, y)", "where(x > y, x, y)"]) +def test_root_math_call_is_not_a_native_reduction(expression): + from blosc2.native_graph import _native_text_expression + + source, reduction = _native_text_expression(expression) + assert source + assert not reduction + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Host thread pools are unavailable on WASM") +def test_numpy_fallback_rebinds_without_retaining_arrays(): + import gc + import importlib + import weakref + from concurrent.futures import ThreadPoolExecutor + + module = importlib.import_module("blosc2.lazyexpr") + + def run(index): + x = np.full(257, index + 0.5) + y = np.full(257, index + 1.5) + output = np.empty(257, dtype="complex128") + refs = [weakref.ref(value) for value in (x, y, output)] + result = blosc2.evaluate("complex(x, y)", local_dict={"x": x, "y": y}, out=output) + assert result is output + np.testing.assert_array_equal(result.real, x) + np.testing.assert_array_equal(result.imag, y) + return refs + + with ThreadPoolExecutor(max_workers=4) as pool: + references = list(pool.map(run, range(12))) + gc.collect() + assert module._evaluate_recipe_cache + assert all(reference() is None for group in references for reference in group) + + +def test_readonly_output_is_rejected_before_writes(): + x = np.arange(17.0) + output = np.full_like(x, -999) + output.flags.writeable = False + with pytest.raises(ValueError, match="read-only"): + blosc2.evaluate("x + 1", local_dict={"x": x}, out=output) + np.testing.assert_array_equal(output, -999) diff --git a/tests/test_evaluate_numpy_prefilter.py b/tests/test_evaluate_numpy_prefilter.py new file mode 100644 index 000000000..a8a7bd829 --- /dev/null +++ b/tests/test_evaluate_numpy_prefilter.py @@ -0,0 +1,177 @@ +"""NumPy output uses bounded prefilter scratch rather than a full stored result.""" + +import numpy as np +import pytest + +import blosc2 +from conftest import orthogonal_cases + + +@pytest.mark.parametrize( + ("dtype", "mode"), + orthogonal_cases( + ["float32", "float64", "int32", "int64", "complex128"], ["evaluate", "getitem", "out", "strided-out"] + ), +) +def test_numpy_prefilter_output(dtype, mode, monkeypatch): + values = np.arange(257, dtype=np.float64).astype(dtype) + if dtype == "complex128": + values += 1j * (values.real + 1) + inputs = { + "x": blosc2.asarray(values, chunks=(128,), blocks=(32,)), + "y": blosc2.asarray(values + 1, chunks=(128,), blocks=(32,)), + } + expected = values + values + expression = "x + (y - 1)" + lazy = blosc2.lazyexpr(expression, inputs) + calls = [] + buffers = [] + original = blosc2.SChunk._prefilter_data + + def prefilter(self, nchunk, data, chunk_data): + calls.append((nchunk, id(chunk_data), chunk_data.size)) + buffers.append(chunk_data) + return original(self, nchunk, data, chunk_data) + + def no_stored_chunks(*args, **kwargs): + pytest.fail("NumPy results must not store intermediate result chunks") + + monkeypatch.setattr(blosc2.SChunk, "_prefilter_data", prefilter) + monkeypatch.setattr(blosc2.SChunk, "update_data", no_stored_chunks) + if mode == "getitem": + result = lazy[:] + elif mode == "evaluate": + result = blosc2.evaluate(expression, local_dict=inputs) + again = blosc2.evaluate(expression, local_dict=inputs) + assert result is not again + np.testing.assert_array_equal(again, expected) + else: + out = np.empty(257 if mode == "out" else 514, dtype=dtype) + if mode == "strided-out": + out[:] = -99 + storage = out + out = out[::2] + result = blosc2.evaluate(expression, local_dict=inputs, out=out) + assert result is out + if mode == "strided-out": + np.testing.assert_array_equal(storage[1::2], -99) + np.testing.assert_array_equal(result, expected) + assert [call[0] for call in calls] == [0, 1, 2] * (2 if mode == "evaluate" else 1) + if mode in ("out", "strided-out"): + assert len({call[1] for call in calls[:3]}) == 1 + assert not np.shares_memory(result, buffers[0]) + else: + assert np.shares_memory(result, buffers[0]) + assert calls[0][2] == 128 * np.dtype(dtype).itemsize + blosc2.MAX_OVERHEAD + + +@pytest.mark.parametrize("force_wasm", [False, True]) +def test_complex_expression_reduction_dispatch(monkeypatch, force_wasm): + import importlib + + if force_wasm: + monkeypatch.setattr(blosc2, "IS_WASM", True) + module = importlib.import_module("blosc2.lazyexpr") + values = np.arange(257, dtype=np.float64) + 1j * np.arange(257, dtype=np.float64)[::-1] + x = blosc2.asarray(values, chunks=(128,), blocks=(32,)) + expression = blosc2.lazyexpr("x * 2", {"x": x}) + + original = module._get_result + calls = [] + + def fallback(*args, **kwargs): + if not blosc2.IS_WASM: + pytest.fail("Complex expression reduction must use miniexpr") + # WASM's scalar reduction prefilter is disabled for all dtypes in + # reduce_slices; complex arithmetic must still work via chunked evaluation. + calls.append(True) + return original(*args, **kwargs) + + monkeypatch.setattr(module, "_get_result", fallback) + np.testing.assert_allclose(expression.sum(), (values * 2).sum()) + assert bool(calls) == blosc2.IS_WASM + + +def test_numpy_prefilter_non_aligned_blocks_fall_back(): + values = np.arange(257, dtype=np.float64) + inputs = {"x": blosc2.asarray(values, chunks=(100,), blocks=(32,))} + out = np.empty_like(values) + result = blosc2.evaluate("x + 1", local_dict=inputs, out=out) + assert result is out + np.testing.assert_array_equal(result, values + 1) + + +@pytest.mark.parametrize("reduction", [False, True]) +def test_prefilter_execution_error_is_not_replayed(monkeypatch, reduction): + import importlib + + if reduction and blosc2.IS_WASM: + pytest.skip("WASM scalar reductions do not install a native prefilter") + module = importlib.import_module("blosc2.lazyexpr") + values = np.arange(257, dtype=np.float64) + inputs = {"x": blosc2.asarray(values, chunks=(128,), blocks=(32,))} + expression = blosc2.lazyexpr("x + 1", inputs) + calls = [] + output = np.full_like(values, -999) + + def execution_error(*args, **kwargs): + calls.append(True) + if not reduction: + output[0] = 12345 # Simulate a partial native destination write. + raise RuntimeError("injected native execution failure") + + def no_replay(*args, **kwargs): + pytest.fail("Native execution errors must not be replayed through NumPy") + + monkeypatch.setattr(blosc2.SChunk, "_prefilter_data", execution_error) + monkeypatch.setattr(module, "_get_result", no_replay) + operation = ( + expression.sum if reduction else lambda: blosc2.evaluate("x + 1", local_dict=inputs, out=output) + ) + with pytest.raises(RuntimeError, match="injected native execution failure"): + operation() + assert calls == [True] + if not reduction: + assert output[0] == 12345 + np.testing.assert_array_equal(output[1:], -999) + + +def test_numpy_prefilter_multidimensional_output_falls_back(): + values = np.arange(99, dtype=np.float64).reshape(9, 11) + inputs = {"x": blosc2.asarray(values, chunks=(4, 6), blocks=(2, 3))} + out = np.empty_like(values) + result = blosc2.evaluate("x + 1", local_dict=inputs, out=out) + assert result is out + np.testing.assert_array_equal(result, values + 1) + + +def test_evaluate_without_options_uses_resident_plan(monkeypatch): + import importlib + + module = importlib.import_module("blosc2.lazyexpr") + module._evaluate_recipe_cache.clear() + + def lazyexpr(*args, **kwargs): + pytest.fail("Resident evaluate constructed a general LazyExpr") + + monkeypatch.setattr(module, "lazyexpr", lazyexpr) + values = np.arange(257, dtype=np.float64) + np.testing.assert_array_equal(blosc2.evaluate("x + 1", local_dict={"x": values}), values + 1) + np.testing.assert_array_equal(blosc2.evaluate("x + 1", local_dict={"x": values}, order="C"), values + 1) + np.testing.assert_array_equal( + blosc2.evaluate("x + 1", local_dict={"x": values}, optimization="moderate"), values + 1 + ) + + +@pytest.mark.parametrize(("size", "chunks", "blocks"), [(100, 9, 1), (257, 128, 32)]) +def test_numpy_prefilter_existing_expression_and_zero_result(size, chunks, blocks): + values = np.arange(size, dtype=np.float32) + inputs = {name: blosc2.asarray(values, chunks=(chunks,), blocks=(blocks,)) for name in ("x", "y")} + out = np.empty_like(values) + blosc2.evaluate("x + y", local_dict=inputs, out=out) + expression = blosc2.lazyexpr("x - y", inputs) + result = blosc2.lazyexpr(expression, operands=inputs, out=out).compute() + assert result is out + np.testing.assert_array_equal(result, 0) + # Fresh calls must also handle all-zero results on the optimized route. + np.testing.assert_array_equal(blosc2.evaluate("x - y", local_dict=inputs), 0) diff --git a/tests/test_evaluate_policy.py b/tests/test_evaluate_policy.py new file mode 100644 index 000000000..a503931a3 --- /dev/null +++ b/tests/test_evaluate_policy.py @@ -0,0 +1,122 @@ +"""String-evaluator defaults are local, explicit overrides remain authoritative.""" + +import importlib +from concurrent.futures import ThreadPoolExecutor + +import numpy as np +import pytest + +import blosc2 + + +@pytest.fixture +def policy_probe(monkeypatch, native_graph_runtime): + monkeypatch.delenv("ME_DSL_JIT", raising=False) + monkeypatch.delenv("BLOSC_ME_JIT", raising=False) + previous = blosc2.set_jit_options(jit=None, jit_backend=None) + native = importlib.import_module("blosc2.native_graph") + original = native.prepare_native_first + original_resident = native.prepare_resident + requests = [] + + def prepare(*args, **kwargs): + requests.append(kwargs["jit"]) + result = original(*args, **kwargs) + if result is not None and kwargs["jit"] is False: + assert not result[0].has_jit + return result + + def resident(*args, **kwargs): + result = original_resident(*args, **kwargs) + if result is not None: + requests.append(kwargs["jit"]) + if kwargs["jit"] is False: + assert not result[1].has_jit + return result + + monkeypatch.setattr(native, "prepare_native_first", prepare) + monkeypatch.setattr(native, "prepare_resident", resident) + try: + yield requests + finally: + blosc2.set_jit_options(**previous) + + +@pytest.mark.parametrize("output", [False, True]) +def test_default_is_interpretation_only_for_evaluate(policy_probe, output): + x = np.arange(32.0) + out = np.empty_like(x) if output else None + result = blosc2.evaluate("x + 1", local_dict={"x": x}, out=out) + assert policy_probe == [None] + np.testing.assert_array_equal(result, x + 1) + if output: + assert result is out + assert blosc2.jit_config.execution_options()["jit"] is None + blosc2.lazyexpr("x + 1", local_dict={"x": x}).compute(out=np.empty_like(x)) + assert policy_probe[-1] is None # Both entry points use native automatic policy. + + +@pytest.mark.parametrize("jit", [False, True]) +@pytest.mark.parametrize("scope", ["context", "global", "environment"]) +def test_explicit_policy_overrides_evaluate_default(policy_probe, monkeypatch, jit, scope): + x = np.arange(32.0) + if scope == "environment": + monkeypatch.setenv("ME_DSL_JIT", str(int(jit))) + elif scope == "global": + blosc2.set_jit_options(jit=jit) + with blosc2.jit_options(**({"jit": jit} if scope == "context" else {})): + np.testing.assert_array_equal(blosc2.evaluate("x + 1", local_dict={"x": x}), x + 1) + assert policy_probe == ([None] if scope == "environment" else [jit]) + + +def test_repeated_and_prepared_evaluators_use_current_policy(policy_probe): + x = np.arange(32.0) + prepared = blosc2.prepare_evaluate("x + 1") + blosc2.evaluate("x + 1", local_dict={"x": x}) + for jit in (True, False): + with blosc2.jit_options(jit=jit): + blosc2.re_evaluate(local_dict={"x": x}) + prepared({"x": x}) + assert policy_probe[-2:] == [jit, jit] + prepared({"x": x}) + assert policy_probe[-1] is None + + +def test_failure_restores_execution_policy(policy_probe): + before = blosc2.jit_config.execution_options() + with pytest.raises(ValueError, match="Unknown keyword"): + blosc2.evaluate("x + 1", local_dict={"x": np.arange(3.0)}, sanitize=False) + assert blosc2.jit_config.execution_options() == before + assert not policy_probe + out = np.empty(3) + out.flags.writeable = False + with pytest.raises(ValueError, match="read-only"): + blosc2.evaluate("x + 1", local_dict={"x": np.arange(3.0)}, out=out) + assert blosc2.jit_config.execution_options() == before + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Host threads unavailable on WASM") +def test_evaluate_default_does_not_leak_across_threads(policy_probe): + def run(jit): + with blosc2.jit_options(jit=jit): + x = np.arange(32.0) + result = blosc2.evaluate("x + 1", local_dict={"x": x}) + np.testing.assert_array_equal(result, x + 1) + assert blosc2.jit_config.execution_options()["jit"] is jit + assert blosc2.jit_config.execution_options()["jit"] is None + + with ThreadPoolExecutor(max_workers=2) as pool: + list(pool.map(run, [False, True])) + assert sorted(policy_probe) == [False, True] + + +@pytest.mark.parametrize("option", ["truediv", "sanitize", "disable_cache"]) +@pytest.mark.parametrize("value", [True, False, None, "auto"]) +def test_removed_options_rejected_by_prepared_evaluators(option, value): + with pytest.raises(ValueError, match=option): + blosc2.prepare_evaluate("x + 1", **{option: value}) + prepared = blosc2.prepare_evaluate("x + 1") + out = np.full(3, -1.0) + with pytest.raises(ValueError, match=option): + prepared({"x": np.arange(3.0)}, out=out, **{option: value}) + np.testing.assert_array_equal(out, -1) diff --git a/tests/test_evaluate_recipe_cache.py b/tests/test_evaluate_recipe_cache.py new file mode 100644 index 000000000..cb26cd46f --- /dev/null +++ b/tests/test_evaluate_recipe_cache.py @@ -0,0 +1,347 @@ +"""Cached preparation never retains operands, outputs or mutable execution state.""" + +import gc +import importlib +import weakref +from concurrent.futures import ThreadPoolExecutor + +import numpy as np +import pytest + +import blosc2 + +module = importlib.import_module("blosc2.lazyexpr") + + +@pytest.fixture(autouse=True) +def empty_recipe_cache(): + with module._evaluate_recipe_lock: + module._evaluate_recipe_cache.clear() + yield + with module._evaluate_recipe_lock: + module._evaluate_recipe_cache.clear() + + +@pytest.mark.parametrize("kind", ["numpy", "blosc2", "mixed"]) +@pytest.mark.parametrize("mode", ["full", "safe"]) +def test_evaluate_cache_rebinds_inputs_and_fresh_outputs(kind, mode, monkeypatch): + def inputs(value): + x = np.arange(257, dtype=np.float64) + value + y = np.ones(257, dtype=np.float64) + if kind != "numpy": + x = blosc2.asarray(x, chunks=(128,), blocks=(32,)) + if kind == "blosc2": + y = blosc2.asarray(y, chunks=(128,), blocks=(32,)) + return {"x": x, "y": y} + + with blosc2.expression_evaluation(mode): + first_inputs = inputs(0) + first = blosc2.evaluate("x + (y - 1)", local_dict=first_inputs) + assert len(module._evaluate_recipe_cache) == 1 + + def forbidden(*args, **kwargs): + pytest.fail("Recipe hit repeated full LazyExpr construction") + + monkeypatch.setattr(blosc2.LazyExpr, "_new_expr", forbidden) + second_inputs = inputs(10) + second = blosc2.evaluate("x + (y - 1)", local_dict=second_inputs) + assert second is not first + assert not np.shares_memory(first, second) + np.testing.assert_array_equal(first, np.arange(257)) + np.testing.assert_array_equal(second, np.arange(257) + 10) + if kind == "numpy": + second_inputs["x"][:] = 99 + np.testing.assert_array_equal(blosc2.evaluate("x + (y - 1)", local_dict=second_inputs), 99) + + +def test_evaluate_cache_signature_and_policy_changes(): + for dtype, shape in [("float32", (12,)), ("float64", (12,)), ("float64", (3, 4))]: + x = np.arange(12, dtype=dtype).reshape(shape) + result = blosc2.evaluate("x + 1", local_dict={"x": x}) + assert result.dtype == np.dtype(dtype) + assert result.shape == shape + np.testing.assert_array_equal(result, x + 1) + assert len(module._evaluate_recipe_cache) == 3 + with blosc2.expression_evaluation("safe"): + np.testing.assert_array_equal(blosc2.evaluate("x + 1", local_dict={"x": x}), x + 1) + assert len(module._evaluate_recipe_cache) == 4 + + +def test_simple_numpy_map_prepares_without_dummy_evaluation(monkeypatch, native_graph_runtime): + x = np.arange(100_000, dtype="float64") + y = x + 1 + + def forbidden(*args, **kwargs): + pytest.fail("Simple NumPy map evaluated synthetic operands") + + monkeypatch.setattr(module, "_numpy_eval_expr", forbidden) + expr = blosc2.lazyexpr("x + (y - 1)", {"x": x, "y": y}) + assert expr.expression == "(o0 + (o1 - 1))" + np.testing.assert_array_equal(expr[:], x + (y - 1)) + assert expr._native_execution_report["evaluated_tiles"] == 2 + np.testing.assert_array_equal(blosc2.evaluate("x + (y - 1)", local_dict={"x": x, "y": y}), x + (y - 1)) + + +def test_plain_arithmetic_shares_preparation(monkeypatch, native_graph_runtime): + x = np.arange(1000, dtype="int64") + y = x + 1 + + def forbidden(*args, **kwargs): + pytest.fail("Reviewed arithmetic preparation repeated legacy validation") + + monkeypatch.setattr(module, "validate_expr", forbidden) + np.testing.assert_array_equal(blosc2.lazyexpr("x + (y - 1)", {"x": x, "y": y})[:], x + (y - 1)) + + first = blosc2.lazyexpr("x + (y - 1)", {"x": x, "y": y}) + second = blosc2.lazyexpr("x + (y - 1)", {"x": x + 10, "y": y}) + assert first._resident_native[1] is second._resident_native[1] + np.testing.assert_array_equal(second[:], x + 10 + (y - 1)) + + +@pytest.mark.parametrize("names", [("x", "e3"), ("α", "β")]) +def test_numpy_rebasing_preserves_numeric_literals_and_aliases(names, native_graph_runtime): + x = np.arange(17.0) + left, right = names + expression = f"{left} + ({right} - 1.e+3)" + expr = blosc2.lazyexpr(expression, {left: x, right: x}) + assert expr.expression == "(o0 + (o0 - 1000.0))" + assert tuple(expr.operands) == ("o0",) + np.testing.assert_array_equal(expr[:], x + (x - 1000.0)) + + +@pytest.mark.parametrize("engine", ["lazyexpr", "evaluate"]) +def test_numpy_preparation_shares_readonly_syntax(monkeypatch, native_graph_runtime, engine): + import ast + + import blosc2.expression_graph as graph + import blosc2.native_graph as native + + for function in ( + graph.expression_syntax, + graph.parse_expression, + native._native_first_syntax, + module._evaluate_recipe_names, + ): + function.cache_clear() + module._evaluate_recipe_cache.clear() + native._native_plan_cache.clear() + monkeypatch.setenv("BLOSC_ME_JIT", "0") + original = ast.parse + parsed = [] + + def record(*args, **kwargs): + parsed.append(args[0]) + return original(*args, **kwargs) + + monkeypatch.setattr(ast, "parse", record) + text = "x + (y - 1)" + x = np.arange(1000, dtype="float64") + y = x + 1 + with blosc2.jit_options(jit=None): + if engine == "lazyexpr": + result = blosc2.lazyexpr(text, {"x": x, "y": y})[:] + else: + result = blosc2.evaluate(text, local_dict={"x": x, "y": y}) + np.testing.assert_array_equal(result, x + (y - 1)) + assert parsed == [text] + syntax, nodes = graph.expression_syntax(text) + assert {node.id for node in nodes if isinstance(node, ast.Name)} == {"x", "y"} + snapshot = ast.dump(syntax, include_attributes=True) + # Aliases change renaming but must leave the cached source untouched. + np.testing.assert_array_equal(blosc2.lazyexpr(text, {"x": y, "y": y})[:], y + (y - 1)) + assert ast.dump(syntax, include_attributes=True) == snapshot + + +def test_prepared_numpy_plan_rebinds_and_invalidates(monkeypatch, native_graph_runtime): + import blosc2.native_graph as native + + monkeypatch.setenv("BLOSC_ME_JIT", "0") + x = np.arange(100_000, dtype="float64") + y = x + 1 + with blosc2.jit_options(jit=None): + expr = blosc2.lazyexpr("x + (y - 1)", {"x": x, "y": y}) + assert hasattr(expr, "_prepared_native") + native._native_plan_cache.clear() + + with monkeypatch.context() as patch: + patch.setattr(native, "lower_native_graph", lambda *args, **kwargs: pytest.fail("Plan rebuilt")) + expr.operands["o0"] = x + 10 + np.testing.assert_array_equal(expr[:], x + 10 + (y - 1)) + + original = native.lower_native_graph + calls = [] + + def record(*args, **kwargs): + calls.append(None) + return original(*args, **kwargs) + + monkeypatch.setattr(native, "lower_native_graph", record) + expr.operands["o0"] = x.astype("float32") + expr.operands["o1"] = y.astype("float32") + native._native_plan_cache.clear() + np.testing.assert_array_equal(expr[:], x.astype("float32") + (y.astype("float32") - 1)) + assert calls + + calls.clear() + native._native_plan_cache.clear() + with blosc2.jit_options(jit=False): + np.testing.assert_array_equal(expr[:], x.astype("float32") + (y.astype("float32") - 1)) + assert calls + + with blosc2.jit_options(jit=True): + assert hasattr(blosc2.lazyexpr("x + (y - 1)", {"x": x, "y": y}), "_prepared_native") + + +def test_jit_numpy_read_reuses_resident_schedule(monkeypatch, native_graph_runtime): + import blosc2.native_graph as native + + monkeypatch.delenv("BLOSC_ME_JIT", raising=False) + x = np.arange(300_000, dtype="float64") + y = x + 1 + with blosc2.jit_options(jit=True): + expr = blosc2.lazyexpr("x + (y - 1)", {"x": x, "y": y}) + prepared = getattr(expr, "_resident_native", None) + if prepared is None: + pytest.skip("Resident schedules are unavailable on this platform") + + def forbidden(*args, **kwargs): + pytest.fail("Prepared JIT read repeated general graph dispatch") + + with monkeypatch.context() as patch: + patch.setattr(native, "prepare_native_first", forbidden) + patch.setattr(prepared[1], "specialize", forbidden) + first = expr[:] + expr.operands["o0"] = x + 10 + second = expr[:] + assert expr._resident_native is prepared + assert not np.shares_memory(first, second) + np.testing.assert_array_equal(first, x + (y - 1)) + np.testing.assert_array_equal(second, x + 10 + (y - 1)) + + # A schedule prepared under JIT must not survive a policy change. + with blosc2.jit_options(jit=False): + np.testing.assert_array_equal(expr[:], x + 10 + (y - 1)) + assert expr._native_execution_report["backend"] == "portable-interpreter" + + +def test_prepared_plan_without_destination_does_not_respecialize(monkeypatch, native_graph_runtime): + import blosc2.native_graph as native + + monkeypatch.setenv("BLOSC_ME_JIT", "0") + x = np.arange(17.0) + with blosc2.jit_options(jit=None): + expr = blosc2.lazyexpr("x + 1", {"x": x}) + plan = expr._prepared_native[1][0] + native._native_plan_cache.clear() + + def forbidden(*args, **kwargs): + pytest.fail("Metadata-identical plan specialized just for admission") + + with monkeypatch.context() as patch: + patch.setattr(plan, "specialize", forbidden) + prepared = native.prepare_native_first(expr, (), jit=None, options={"_getitem": True}) + assert prepared[0] is plan + np.testing.assert_array_equal(expr[:], x + 1) + + +def test_evaluate_cache_caller_and_explicit_namespace_resolution(): + x = np.arange(12, dtype=np.float64) + np.testing.assert_array_equal(blosc2.evaluate("x + 1"), x + 1) + x = np.arange(12, dtype=np.float64) + 10 + np.testing.assert_array_equal(blosc2.evaluate("x + 1"), x + 1) + np.testing.assert_array_equal(blosc2.evaluate("x + 1", local_dict={}, global_dict={"x": x}), x + 1) + assert len(module._evaluate_recipe_cache) == 1 + + +@pytest.mark.parametrize("kind", ["numpy", "blosc2"]) +def test_evaluate_cache_does_not_retain_arrays(kind): + x = np.arange(257, dtype=np.float64) + if kind == "blosc2": + x = blosc2.asarray(x, chunks=(128,), blocks=(32,)) + reference = weakref.ref(x) + output = blosc2.evaluate("x + 1", local_dict={"x": x}) + output_ref = weakref.ref(output) + assert module._evaluate_recipe_cache + del x, output + gc.collect() + assert reference() is None + assert output_ref() is None + + +def test_evaluate_cache_is_bounded(monkeypatch): + monkeypatch.setattr(module, "_EVALUATE_RECIPE_CACHE_SIZE", 3) + x = np.arange(12, dtype=np.float64) + for value in range(6): + np.testing.assert_array_equal(blosc2.evaluate(f"x + {value}", local_dict={"x": x}), x + value) + assert len(module._evaluate_recipe_cache) == 3 + assert [key[0] for key in module._evaluate_recipe_cache] == ["x + 3", "x + 4", "x + 5"] + + +@pytest.mark.parametrize("mode", ["full", "safe"]) +@pytest.mark.skipif(blosc2.IS_WASM, reason="Concurrent cache calls require host threads") +def test_evaluate_cache_concurrent_calls(mode): + def run(value): + x = np.arange(257, dtype=np.float64) + value + with blosc2.expression_evaluation(mode): + result = blosc2.evaluate("x + 1", local_dict={"x": x}) + np.testing.assert_array_equal(result, x + 1) + return result + + # Exercise racing misses as well as repeated hits on an immutable recipe. + with ThreadPoolExecutor(max_workers=4) as pool: + results = list(pool.map(run, range(24))) + assert len(module._evaluate_recipe_cache) == 1 + assert len({id(result) for result in results}) == 24 + + +def test_evaluate_cache_excludes_captures_options_and_aliases(): + x = np.arange(12, dtype=np.float64) + np.testing.assert_array_equal(blosc2.evaluate("x + c", local_dict={"x": x, "c": 2}), x + 2) + np.testing.assert_array_equal(blosc2.evaluate("x + c", local_dict={"x": x, "c": 3}), x + 3) + np.testing.assert_array_equal(blosc2.evaluate("x + y", local_dict={"x": x, "y": x}), x + x) + assert not module._evaluate_recipe_cache + out = np.empty_like(x) + assert blosc2.evaluate("x + 1", local_dict={"x": x}, out=out) is out + np.testing.assert_array_equal(blosc2.evaluate("x + 1", local_dict={"x": x}, order="C"), x + 1) + assert len(module._evaluate_recipe_cache) == 1 # Explicit output is rebound, not cached. + + +def test_evaluate_cache_checks_current_array_layout(): + x = np.arange(12, dtype=np.float64) + blosc2.evaluate("x + 1", local_dict={"x": x}) + x = np.arange(24, dtype=np.float64)[::2] + np.testing.assert_array_equal(blosc2.evaluate("x + 1", local_dict={"x": x}), x + 1) + assert len(module._evaluate_recipe_cache) == 1 + + +def test_evaluate_cache_storage_layout_changes(): + x = np.arange(257, dtype=np.float64) + for chunks, blocks in [(128, 32), (100, 25)]: + source = blosc2.asarray(x, chunks=(chunks,), blocks=(blocks,)) + np.testing.assert_array_equal(blosc2.evaluate("x + 1", local_dict={"x": source}), x + 1) + assert len(module._evaluate_recipe_cache) == 2 + + +def test_evaluate_cache_does_not_retain_dtype_metadata_owners(): + owner = np.arange(12) + dtype = np.dtype("float64", metadata={"owner": owner}) + x = np.arange(12, dtype=dtype) + reference = weakref.ref(owner) + result = blosc2.evaluate("x + 1", local_dict={"x": x}) + np.testing.assert_array_equal(result, np.arange(12) + 1) + assert not module._evaluate_recipe_cache + del x, owner, dtype, result + gc.collect() + assert reference() is None + + +def test_evaluate_recipe_has_no_mutable_execution_state(): + x = np.arange(257, dtype=np.float64) + first = module._prepare_cached_evaluate("x + 1", {"x": x}, None) + plan, inputs = first + plan[2].execute(inputs) + second = module._prepare_cached_evaluate("x + 1", {"x": x + 10}, None) + assert second is not first + assert second[1] is not first[1] + assert second[0] is first[0] + np.testing.assert_array_equal(second[0][2].execute(second[1])[0], x + 11) diff --git a/tests/test_expression_graph.py b/tests/test_expression_graph.py new file mode 100644 index 000000000..4bdeefe0e --- /dev/null +++ b/tests/test_expression_graph.py @@ -0,0 +1,1444 @@ +"""Safe graph lifetime, syntax, operands and trusted compatibility checks.""" + +import importlib +import sys +from concurrent.futures import ThreadPoolExecutor +from threading import Event + +import numpy as np +import pytest + +import blosc2 +from blosc2.expression_graph import parse_expression +from conftest import orthogonal_cases + + +def _numpy_cumulative_reference(data, name, *, axis, include_initial): + if hasattr(np, name): + return getattr(np, name)(data, axis=axis, include_initial=include_initial) + legacy = "cumsum" if name == "cumulative_sum" else "cumprod" + if include_initial: + shape = list(data.shape) + shape[axis] = 1 + identity = np.full(shape, 0 if legacy == "cumsum" else 1, dtype=data.dtype) + data = np.concatenate((identity, data), axis=axis) + return getattr(np, legacy)(data, axis=axis) + + +@pytest.fixture(autouse=True) +def safe_graph_context(): + # Phase 1 protects loaded expressions; explicit context exercises the same + # engine in memory without changing the ordinary construction default. + with blosc2.expression_evaluation("safe"): + yield + + +@pytest.mark.parametrize( + "expression", + [ + "sqrt(x) + y", + "sum(x)", + "x.mean(axis=0)", + "x[0]", + "x - mean(x)", + ], +) +@pytest.mark.parametrize("route", ["memory", "disk", "frame", "full"]) +def test_safe_graph_end_to_end(tmp_path, monkeypatch, expression, route): + x = np.arange(1, 13, dtype="float64").reshape(3, 4) + y = np.ones((3, 4)) + operands = { + "x": blosc2.asarray(x, urlpath=tmp_path / "x.b2nd", mode="w"), + "y": blosc2.asarray(y, urlpath=tmp_path / "y.b2nd", mode="w"), + } + expected = { + "sqrt(x) + y": np.sqrt(x) + y, + "sum(x)": x.sum(), + "x.mean(axis=0)": x.mean(axis=0), + "x[0]": x[0], + "x - mean(x)": x - x.mean(), + }[expression] + graph_module = importlib.import_module("blosc2.expression_graph") + if route != "full": + monkeypatch.setattr( + graph_module, "eval", lambda *a: pytest.fail("Python text evaluation"), raising=False + ) + expr = blosc2.lazyexpr(expression, operands) + if route in ("disk", "full"): + path = tmp_path / "expression.b2nd" + expr.save(path) + expr = blosc2.open(path, deserialize="full" if route == "full" else "safe") + elif route == "frame": + expr = blosc2.from_cframe(expr.to_cframe()) + np.testing.assert_allclose(expr[()], expected) + np.testing.assert_allclose(expr.compute()[()], expected) + np.testing.assert_allclose(expr[()], expected) + + +@pytest.mark.parametrize( + "text", + [ + "open('sentinel')", + "x.__class__", + "x.dtype.type(x)", + "np.load('sentinel')", + "blosc2.open('sentinel')", + "(lambda: 1)()", + "[v for v in x]", + "sin(x, urlpath='sentinel')", + "sum(x, callback=x)", + "sqrt(*x)", + "sqrt()", + "x[open('sentinel')]", + "zeros((2,), urlpath='sentinel')", + ], +) +def test_forbidden_recipe_rejects_before_resolution(monkeypatch, text): + module = importlib.import_module("blosc2.b2objects") + monkeypatch.setattr( + module, "decode_operand_mapping", lambda *a, **k: pytest.fail("Resolved invalid recipe") + ) + with pytest.raises((blosc2.UnsafeDeserializationError, ValueError)): + module.decode_structured_lazyexpr({"expression": text, "operands": {}}) + + +def test_operand_hooks_are_not_called(): + class Hostile: + @property + def dtype(self): + pytest.fail("Read untrusted metadata") + + @property + def shape(self): + pytest.fail("Read untrusted metadata") + + def __array__(self, *a, **k): + pytest.fail("Coerced untrusted operand") + + with pytest.raises(blosc2.UnsafeDeserializationError, match="Hostile"): + blosc2.lazyexpr("sqrt(x)", {"x": Hostile()}) + + class Subclass(np.ndarray): + def __array_ufunc__(self, *a, **k): + pytest.fail("Dispatched untrusted ufunc") + + with pytest.raises(blosc2.UnsafeDeserializationError, match="Subclass"): + blosc2.lazyexpr("sqrt(x)", {"x": np.arange(3).view(Subclass)}) + objects = np.empty(1, dtype=object) + objects[0] = Hostile() + with pytest.raises(blosc2.UnsafeDeserializationError, match="object-dtype"): + blosc2.lazyexpr("x + 1", {"x": objects}) + + +def test_mutation_revalidates_and_results_are_not_cached(): + x = blosc2.asarray(np.array([1.0, 3.0, 5.0])) + expr = blosc2.lazyexpr("x - mean(x)", {"x": x}) + np.testing.assert_allclose(expr[:], [-2, 0, 2]) + x[:] = [1.0, 1.0, 7.0] + np.testing.assert_allclose(expr[:], [-2, -2, 4]) + expr.expression = "open('sentinel')" + with pytest.raises(blosc2.UnsafeDeserializationError): + expr.compute() + + +def test_cyclic_expression_operands_reject(): + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(3)}) + expr.operands["x"] = expr + with pytest.raises(blosc2.UnsafeDeserializationError, match="cyclic"): + expr.compute() + + +def test_registered_calls_do_not_resolve_caller_names(): + def sqrt(x): + pytest.fail("Resolved caller callable") + + x = np.arange(4, dtype="float64") + np.testing.assert_allclose(blosc2.lazyexpr("sqrt(x)")[:], np.sqrt(x)) + assert callable(sqrt) + + +def test_parser_bounds_and_immutable_plan_cache(): + assert parse_expression("x + 1") is parse_expression("x + 1") + with pytest.raises(blosc2.UnsafeDeserializationError, match="65536"): + parse_expression(" " * 65537) + with pytest.raises(blosc2.UnsafeDeserializationError, match="levels"): + parse_expression("-" * 65 + "x") + + +def test_trusted_legacy_context_restores_safe_default(): + x = np.arange(4) + with blosc2.expression_evaluation("full"): + expr = blosc2.lazyexpr("cumsum(x)", {"x": x}) + np.testing.assert_array_equal(expr[:], np.cumsum(x)) + with pytest.raises(blosc2.UnsafeDeserializationError): + blosc2.lazyexpr("np.load('sentinel')", {}) + + +def test_full_permission_numerical_graph_composes_safely(tmp_path): + x = blosc2.asarray(np.arange(4.0), urlpath=tmp_path / "x.b2nd", mode="w") + expr = blosc2.lazyexpr("sqrt(x)", {"x": x}) + expr.save(tmp_path / "expr.b2nd") + opened = blosc2.open(tmp_path / "expr.b2nd", deserialize="full") + assert opened._evaluation == "safe" + np.testing.assert_allclose((opened + x)[:], np.sqrt(x[:]) + x[:]) + + +def test_custom_metaclass_hooks_are_not_called(): + class Metaclass(type): + def __hash__(self): + pytest.fail("Hashed an untrusted class") + + class Hostile(metaclass=Metaclass): + pass + + with pytest.raises(blosc2.UnsafeDeserializationError, match="metaclass"): + blosc2.lazyexpr("x + 1", {"x": Hostile()}) + + +def test_cyclic_container_rejects_before_metadata(): + values = [] + values.append(values) + with pytest.raises(blosc2.UnsafeDeserializationError, match="cyclic"): + blosc2.lazyexpr("x + 1", {"x": values}) + + +def test_shared_dependency_and_partial_global_reduction(): + x = blosc2.asarray(np.arange(20.0)) + expr = blosc2.lazyexpr("x - mean(x)", {"x": x}) + np.testing.assert_allclose(expr[:3], (x[:] - x[:].mean())[:3]) + shared = blosc2.lazyexpr("a + b", {"a": expr, "b": expr}) + np.testing.assert_allclose(shared[:], 2 * (x[:] - x[:].mean())) + + +def test_loaded_graph_cannot_downgrade_through_composition(tmp_path, monkeypatch): + module = importlib.import_module("blosc2.expression_graph") + x = blosc2.asarray(np.arange(4.0), urlpath=tmp_path / "x.b2nd", mode="w") + blosc2.lazyexpr("sqrt(x)", {"x": x}).save(tmp_path / "expr.b2nd") + # Leave the explicit test context: opening/composition must establish their + # own lifetime boundary even though ordinary construction is trusted. + with blosc2.expression_evaluation("full"): + opened = blosc2.open(tmp_path / "expr.b2nd") + monkeypatch.setattr(module, "eval", lambda *a: pytest.fail("Legacy bridge reached"), raising=False) + composed = opened + 1 + assert composed._evaluation == "safe" + np.testing.assert_allclose(composed[:], np.sqrt(x[:]) + 1) + selected = (opened > 0).where(opened, 0) + assert selected._evaluation == "safe" + np.testing.assert_allclose(selected[:], np.sqrt(x[:])) + np.testing.assert_allclose(opened.mean()[()], np.sqrt(x[:]).mean()) + np.testing.assert_allclose(opened.var()[()], np.sqrt(x[:]).var()) + composed.expression = "np.load('sentinel')" + with pytest.raises(blosc2.UnsafeDeserializationError): + composed.compute() + + +def test_safe_where_admits_before_coercion(): + class Hostile: + @property + def dtype(self): + pytest.fail("Read selection operand metadata") + + condition = blosc2.lazyexpr("x > 0", {"x": np.arange(4)}) + with pytest.raises(blosc2.UnsafeDeserializationError, match="Hostile"): + condition.where(Hostile(), 0) + selected = condition.where(1, 0) + selected._where_args["_where_x"] = Hostile() + with pytest.raises(blosc2.UnsafeDeserializationError, match="Hostile"): + selected.compute() + + +def test_proxy_wrapper_does_not_hide_custom_source(): + class Source: + shape = (4,) + dtype = np.dtype("float64") + + def __getitem__(self, item): + pytest.fail("Read untrusted proxy source") + + wrapper = blosc2.SimpleProxy(Source()) + with pytest.raises(blosc2.UnsafeDeserializationError, match="Source"): + blosc2.lazyexpr("sqrt(x)", {"x": wrapper}) + + +def test_centering_reduces_once_per_evaluation_across_chunks(monkeypatch): + module = importlib.import_module("blosc2.lazyexpr") + data = np.arange(1000.0) + x = blosc2.asarray(data, chunks=(100,), blocks=(20,)) + expr = blosc2.lazyexpr("x - mean(x)", {"x": x}) + original = module.reduce_slices + calls = [] + + def counted(expression, operands, reduce_args, *args, **kwargs): + calls.append(reduce_args["op_str"]) + return original(expression, operands, reduce_args, *args, **kwargs) + + monkeypatch.setattr(module, "reduce_slices", counted) + np.testing.assert_allclose(expr[:], data - data.mean()) + assert calls == ["sum"] + calls.clear() + x[:] = data * 2 + np.testing.assert_allclose(expr[:], 2 * (data - data.mean())) + assert calls == ["sum"] + + +def test_metadata_refreshes_after_rebinding_before_first_compute(): + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(6, dtype="int32")}) + key = next(iter(expr.operands)) + replacement = np.arange(12, dtype="float64").reshape(3, 4) + expr.operands[key] = replacement + assert expr.shape == (3, 4) + assert expr.dtype == np.dtype("float64") + np.testing.assert_allclose(expr[:], replacement + 1) + + +def test_metadata_refreshes_after_shape_mutation_and_text_change(): + source = np.arange(12.0) + expr = blosc2.lazyexpr("x + 1", {"x": source}) + assert expr.shape == (12,) + source.resize((3, 4), refcheck=False) + assert expr.shape == (3, 4) + np.testing.assert_allclose(expr[:], source + 1) + key = next(iter(expr.operands)) + expr.expression = f"sum({key}, axis=0)" + assert expr.shape == (4,) + np.testing.assert_allclose(expr[:], source.sum(axis=0)) + + +def test_metadata_refreshes_selection_dtype(): + expr = blosc2.lazyexpr("x > 0", {"x": np.arange(4)}).where(1, 0) + assert expr.dtype == np.asarray(1).dtype + expr._where_args["_where_x"] = np.float64(1.5) + assert expr.dtype == np.dtype("float64") + np.testing.assert_allclose(expr[:], [0, 1.5, 1.5, 1.5]) + + +def test_data_changes_do_not_rebuild_metadata_or_cache_results(monkeypatch): + module = importlib.import_module("blosc2.expression_graph") + source = np.arange(4.0) + expr = blosc2.lazyexpr("x + 1", {"x": source}) + state = expr._graph_metadata + original = module.record_expression_metadata + + def unexpected_rebuild(value): + if value is not expr: + pytest.fail("Rebuilt expression metadata after a data-only change") + return original(value) + + monkeypatch.setattr(module, "record_expression_metadata", unexpected_rebuild) + source[:] = 10 + np.testing.assert_allclose(expr[:], [11, 11, 11, 11]) + assert expr._graph_metadata == state + + +@pytest.mark.parametrize("route", ["disk", "frame", "structured"]) +def test_mutated_recipe_roundtrip_uses_current_metadata(tmp_path, route): + source = blosc2.asarray(np.arange(6, dtype="int32"), urlpath=tmp_path / "old.b2nd", mode="w") + expr = blosc2.lazyexpr("x + 1", {"x": source}) + key = next(iter(expr.operands)) + data = np.arange(12.0).reshape(3, 4) + expr.operands[key] = blosc2.asarray(data, urlpath=tmp_path / "new.b2nd", mode="w") + expr.expression = f"sqrt({key})" + if route == "disk": + expr.save(tmp_path / "expr.b2nd") + reopened = blosc2.open(tmp_path / "expr.b2nd") + elif route == "frame": + reopened = blosc2.from_cframe(expr.to_cframe()) + else: + module = importlib.import_module("blosc2.b2objects") + reopened = module.decode_b2object_payload(module.encode_b2object_payload(expr)) + assert reopened.shape == (3, 4) + assert reopened.dtype == np.dtype("float64") + np.testing.assert_allclose(reopened[:], np.sqrt(data)) + + +def test_trusted_numerical_dependency_does_not_import_stale_metadata(): + source = np.arange(6.0) + with blosc2.expression_evaluation("full"): + trusted = blosc2.lazyexpr("x + 1", {"x": source}) + source.resize((2, 3), refcheck=False) + combined = blosc2.lazyexpr("x + 1", {"x": trusted}) + assert trusted.shape == (2, 3) + assert combined.shape == (2, 3) + np.testing.assert_allclose(combined[:], source + 2) + + +def test_failed_metadata_refresh_never_returns_old_shape(): + expr = blosc2.lazyexpr("x + y", {"x": np.ones(4), "y": np.ones(4)}) + key = next(iter(expr.operands)) + expr.operands[key] = np.ones(3) + with pytest.raises(ValueError): + _ = expr.shape + with pytest.raises(ValueError): + expr.compute() + + +@pytest.mark.parametrize( + "text", + [ + "sum(x, axis='rows')", + "mean(x, axis=1.5)", + "sum(x, axis=(0, 0))", + "argmax(x, axis=(0, 1))", + "sum(x, keepdims='yes')", + "sum(x, dtype='O')", + "mean(x, dtype='not-a-dtype')", + "std(x, ddof='one')", + "var(x, ddof=1, correction=1)", + "sum(x, ddof=1)", + "count_nonzero(x, dtype='int64')", + "sum(x, 0, axis=1)", + "sum(x, 0, float64, dtype=float32)", + "x.astype()", + "x.astype('O')", + "x.astype('float32', copy='yes')", + "x.astype('float32', order='wrong')", + "x.astype('float32', casting='sometimes')", + "x.astype('float32', dtype=float64)", + ], +) +def test_operation_contract_rejects_literals_before_resolution(monkeypatch, text): + module = importlib.import_module("blosc2.b2objects") + monkeypatch.setattr( + module, "decode_operand_mapping", lambda *a, **k: pytest.fail("Resolved malformed recipe") + ) + with pytest.raises(blosc2.UnsafeDeserializationError): + module.decode_structured_lazyexpr({"expression": text, "operands": {}}) + + +@pytest.mark.parametrize("axis", [None, 0, -1, (0, 2), np.int64(1)]) +def test_reduction_axis_contract_preserves_numpy_results(axis): + x = np.arange(24.0).reshape(2, 3, 4) + graph = parse_expression("sum(x, axis=axis, keepdims=True)") + result = graph.evaluate({"x": x, "axis": axis}) + np.testing.assert_allclose(result, x.sum(axis=axis, keepdims=True)) + + +def test_runtime_contract_rejects_bound_invalid_axis_before_dispatch(monkeypatch): + graph = parse_expression("sum(x, axis=axis)") + monkeypatch.setattr(np, "sum", lambda *a, **k: pytest.fail("Dispatched invalid axis")) + with pytest.raises(blosc2.UnsafeDeserializationError, match="axis"): + graph.evaluate({"x": np.arange(4), "axis": "rows"}) + + +def test_cast_contract_preserves_numpy_results(): + x = np.arange(4.0) + graph = parse_expression("x.astype(float32, order='C', casting='unsafe', copy=False)") + result = graph.evaluate({"x": x}) + assert result.dtype == np.dtype("float32") + np.testing.assert_allclose(result, x.astype("float32")) + + +def test_contracted_operation_safe_roundtrip(tmp_path): + text = "sum(x, axis=-1, keepdims=True)" + data = np.arange(12.0).reshape(3, 4) + x = blosc2.asarray(data, urlpath=tmp_path / "x.b2nd", mode="w") + expr = blosc2.lazyexpr(text, {"x": x}) + expr.save(tmp_path / "expr.b2nd") + reopened = blosc2.open(tmp_path / "expr.b2nd") + expected = data.sum(axis=-1, keepdims=True) + np.testing.assert_allclose(reopened[:], expected) + + +def test_intermediate_cache_distinguishes_equal_typed_literals(): + values = parse_expression("(True, 1, 1.0, 1 + 0j)").evaluate({}) + assert tuple(type(value) for value in values) == (bool, int, float, complex) + result = parse_expression("1 + 1.0").evaluate({}) + assert type(result) is float + result = parse_expression("where(x < 1, 1, 1.0)").evaluate({"x": np.arange(3)}) + assert result.dtype == np.dtype("float64") + + +def test_equal_reduction_nodes_still_share_one_intermediate(monkeypatch): + original = np.sum + calls = [] + + def counted(*args, **kwargs): + calls.append(1) + return original(*args, **kwargs) + + monkeypatch.setattr(np, "sum", counted) + x = np.arange(4.0) + result = parse_expression("sum(x) + sum(x)").evaluate({"x": x}) + assert result == 12 + assert len(calls) == 1 + + +@pytest.mark.parametrize("backend", ["numpy", "blosc_array", "blosc_lazy"]) +@pytest.mark.parametrize( + "name", ["sum", "mean", "std", "var", "min", "max", "any", "all", "argmin", "argmax"] +) +def test_backend_positional_reduction_binding(backend, name): + data = np.arange(12.0).reshape(3, 4) + x = data if backend == "numpy" else blosc2.asarray(data) + if backend == "blosc_lazy": + x = blosc2.LazyExpr((x, None, None)) + if name in {"sum", "mean"}: + arguments = "0, None, None, True" if backend == "numpy" else "0, None, True" + elif name in {"std", "var"}: + arguments = { + "numpy": "0, None, None, 1, True", + "blosc_array": "0, None, 1, True", + "blosc_lazy": "0, None, True, 1", + }[backend] + elif name in {"argmin", "argmax"}: + arguments = "0, None, keepdims=True" if backend == "numpy" else "0, True" + else: + arguments = "0, None, True" if backend == "numpy" else "0, True" + expr = blosc2.lazyexpr(f"x.{name}({arguments})", {"x": x}) + options = {"axis": 0, "keepdims": True} + if name in {"std", "var"}: + options["ddof"] = 1 + expected = getattr(x, name)(**options) + assert expr.shape == expected.shape + assert expr.dtype == expected.dtype + np.testing.assert_allclose(expr[:], expected) + + +@pytest.mark.parametrize( + ("dtype", "name"), + orthogonal_cases( + ["bool", "int8", "uint8", "float16", "float32", "float64", "complex64"], + ["sum", "prod", "mean", "std", "var", "min", "max", "any", "all", "argmin", "argmax"], + ) + + [("complex64", "min"), ("complex64", "max")], +) +def test_root_reduction_metadata_matches_execution(dtype, name): + data = (np.arange(24).reshape(2, 3, 4) % 5).astype(dtype) + x = blosc2.asarray(data) + axis = -1 if name in {"argmin", "argmax"} else (0, -1) + expr = blosc2.lazyexpr(f"x.{name}(axis={axis!r}, keepdims=True)", {"x": x}) + try: + expected = getattr(x, name)(axis=axis, keepdims=True) + except RuntimeWarning: + if dtype != "complex64" or name not in {"min", "max"}: + raise + # Native complex extrema may warn when constructing identities; WASM's + # NumPy fallback need not. Preserve the actual backend's behavior. + with pytest.raises(RuntimeWarning): + expr.compute() + return + values = np.asarray(expected) + assert expr.shape == values.shape + assert expr.dtype == values.dtype + np.testing.assert_allclose(expr[:], values, rtol=1e-6) + + +def test_data_free_metadata_does_not_execute_reduction(monkeypatch): + module = importlib.import_module("blosc2.lazyexpr") + x = blosc2.asarray(np.arange(24.0).reshape(2, 3, 4)) + monkeypatch.setattr( + module, "reduce_slices", lambda *a, **k: pytest.fail("Executed a reduction to infer metadata") + ) + expr = blosc2.lazyexpr("x.std(axis=(0, 2), ddof=2, keepdims=True)", {"x": x}) + assert expr.shape == (1, 3, 1) + assert expr.dtype == np.dtype("float64") + + +@pytest.mark.parametrize("text", ["sum(x, axis=3)", "sum(x, axis=(0, -2))"]) +def test_root_reduction_axis_bounds_reject_during_inference(text): + with pytest.raises(ValueError): + blosc2.lazyexpr(text, {"x": blosc2.ones((2, 3))}) + + +def test_binding_preserves_grouping_in_non_reduction_composition(): + x = np.arange(4.0) + expr = blosc2.lazyexpr("(x - 1)", {"x": x}) + np.testing.assert_allclose((expr**2)[:], (x - 1) ** 2) + + +def test_backend_rejects_duplicate_non_prefix_positional_argument(): + graph = parse_expression("x.sum(0, None, True, keepdims=False)") + with pytest.raises(blosc2.UnsafeDeserializationError, match=r"duplicate.*keepdims"): + graph.evaluate({"x": blosc2.ones((2, 3))}) + + +def test_numpy_out_position_is_not_blosc_keepdims(): + x = np.arange(6.0).reshape(2, 3) + target = np.empty(3) + result = parse_expression("x.sum(0, None, out)").evaluate({"x": x, "out": target}) + assert result is target + np.testing.assert_allclose(result, x.sum(axis=0)) + + +def test_root_binding_preserves_equal_differently_typed_arguments(): + data = np.arange(6.0).reshape(2, 3) + expr = blosc2.lazyexpr("x.sum(1, None, True)", {"x": blosc2.asarray(data)}) + assert expr.shape == (2, 1) + np.testing.assert_allclose(expr[:], data.sum(axis=1, keepdims=True)) + + +@pytest.mark.parametrize("text", ["x.std(0, None, 1, True)", "var(x, 0, None, 1, True)"]) +def test_bound_reduction_persistence_keeps_axis_dtype_and_ddof(tmp_path, text): + data = np.arange(12.0).reshape(3, 4) + x = blosc2.asarray(data, urlpath=tmp_path / "x.b2nd", mode="w") + expr = blosc2.lazyexpr(text, {"x": x}) + expr.save(tmp_path / "expr.b2nd") + reopened = blosc2.open(tmp_path / "expr.b2nd") + expected = ( + data.std(axis=0, ddof=1, keepdims=True) + if text.startswith("x.std") + else data.var(axis=0, ddof=1, keepdims=True) + ) + assert reopened.shape == expected.shape + assert reopened.dtype == expected.dtype + np.testing.assert_allclose(reopened[:], expected) + + +def test_numpy_forwarding_function_keeps_supported_initial_keyword(): + data = np.arange(6.0).reshape(2, 3) + expr = blosc2.lazyexpr("sum(x, axis=0, initial=5)", {"x": data}) + np.testing.assert_allclose(expr[:], data.sum(axis=0, initial=5)) + + +def test_unsupported_blosc_keyword_rejects_before_reduction_dispatch(monkeypatch): + x = blosc2.ones((2, 3)) + monkeypatch.setattr(blosc2, "sum", lambda *a, **k: pytest.fail("Dispatched unsupported initial")) + with pytest.raises(blosc2.UnsafeDeserializationError, match=r"unsupported.*signature"): + parse_expression("sum(x, initial=5)").evaluate({"x": x}, prefer_blosc=True) + + +@pytest.mark.parametrize("namespace", ["np", "numpy"]) +def test_numpy_qualified_reduction_preserves_numpy_position_layout(namespace): + data = np.arange(6.0).reshape(2, 3) + x = blosc2.asarray(data) + expr = blosc2.lazyexpr(f"{namespace}.sum(x, 0, None, None, True)", {"x": x}) + assert expr.shape == (1, 3) + np.testing.assert_allclose(expr[:], data.sum(axis=0, keepdims=True)) + + +def test_blosc_qualified_reduction_preserves_blosc_position_layout(): + data = np.arange(6.0).reshape(2, 3) + expr = blosc2.lazyexpr("blosc2.sum(x, 0, None, True)", {"x": data}) + assert expr.shape == (1, 3) + np.testing.assert_allclose(expr[:], data.sum(axis=0, keepdims=True)) + + +@pytest.mark.parametrize("name", ["cumulative_sum", "cumulative_prod"]) +@pytest.mark.parametrize( + ("backend", "include_initial", "dtype"), + orthogonal_cases( + ["numpy", "blosc_function", "blosc_array", "blosc_lazy"], + [False, True], + ["int8", "uint8", "float32", "float64"], + ), +) +def test_cumulative_backend_layout_and_metadata(name, backend, include_initial, dtype): + if backend == "numpy" and not hasattr(np, name): + pytest.skip(f"NumPy version has no {name} function") + data = (np.arange(6).reshape(2, 3) % 3 + 1).astype(dtype) + x = data if backend == "numpy" else blosc2.asarray(data) + if backend == "blosc_lazy": + x = blosc2.LazyExpr((x, None, None)) + text = { + "numpy": f"np.{name}(x, axis=-1, include_initial={include_initial})", + "blosc_function": f"blosc2.{name}(x, -1, None, {include_initial})", + "blosc_array": f"x.{name}(-1, None, {include_initial})", + "blosc_lazy": f"x.{name}(-1, {include_initial})", + }[backend] + expr = blosc2.lazyexpr(text, {"x": x}) + expected = _numpy_cumulative_reference(data, name, axis=-1, include_initial=include_initial) + assert expr.shape == expected.shape + assert expr.dtype == expected.dtype + np.testing.assert_allclose(expr[:], expected, rtol=1e-6) + + +@pytest.mark.parametrize("name", ["cumsum", "cumprod"]) +@pytest.mark.parametrize("axis", [None, 0, -1]) +def test_numpy_cumulative_legacy_flattening_and_out(name, axis): + data = np.arange(1, 7, dtype="int8").reshape(2, 3) + expected = getattr(data, name)(axis=axis, dtype="float64") + expr = blosc2.lazyexpr(f"x.{name}({axis}, 'float64')", {"x": data}) + assert expr.shape == expected.shape + assert expr.dtype == expected.dtype + np.testing.assert_allclose(expr[:], expected) + out = np.empty(expected.shape) + result = parse_expression(f"x.{name}({axis}, 'float64', out)").evaluate({"x": data, "out": out}) + assert result is out + np.testing.assert_allclose(out, expected) + + +@pytest.mark.parametrize( + "text", + [ + "np.cumulative_sum(x, 0)", + "x.cumulative_sum(0, True, include_initial=False)", + "x.cumulative_sum(axis=0, include_initial=1)", + "x.cumulative_sum(axis=(0,))", + "x.cumulative_sum(axis=2)", + ], +) +def test_cumulative_invalid_contract_rejects_before_dispatch(text, monkeypatch): + data = blosc2.ones((2, 3)) + x = blosc2.LazyExpr((data, None, None)) + monkeypatch.setattr(blosc2.LazyExpr, "cumulative_sum", lambda *a, **k: pytest.fail("Invalid dispatch")) + with pytest.raises((blosc2.UnsafeDeserializationError, ValueError)): + parse_expression(text).evaluate({"x": x}) + + +@pytest.mark.parametrize("name", ["cumulative_sum", "cumulative_prod"]) +def test_cumulative_axis_none_requires_one_dimension(name): + with pytest.raises(ValueError, match="axis must be specified"): + blosc2.lazyexpr(f"x.{name}()", {"x": blosc2.ones((2, 3))}) + data = np.arange(1, 4) + expr = blosc2.lazyexpr(f"x.{name}(include_initial=True)", {"x": blosc2.asarray(data)}) + assert expr.shape == (4,) + np.testing.assert_array_equal( + expr[:], _numpy_cumulative_reference(data, name, axis=0, include_initial=True) + ) + + +def test_cumulative_root_metadata_is_data_free(monkeypatch): + x = blosc2.ones((2, 3)) + monkeypatch.setattr(blosc2.NDArray, "cumulative_sum", lambda *a, **k: pytest.fail("Dummy execution")) + expr = blosc2.lazyexpr("x.cumulative_sum(1, None, True)", {"x": x}) + assert expr.shape == (2, 4) + assert expr.dtype == np.dtype("float64") + + +def test_cumulative_persistence_preserves_include_initial(tmp_path): + data = np.arange(1, 7, dtype="int8").reshape(2, 3) + x = blosc2.asarray(data, urlpath=tmp_path / "input.b2nd", mode="w") + expr = blosc2.lazyexpr("x.cumulative_sum(1, None, True)", {"x": x}) + expr.save(tmp_path / "expr.b2nd") + opened = blosc2.open(tmp_path / "expr.b2nd") + expected = _numpy_cumulative_reference(data, "cumulative_sum", axis=1, include_initial=True) + assert opened.shape == expected.shape + assert opened.dtype == expected.dtype + np.testing.assert_array_equal(opened[:], expected) + + +@pytest.mark.parametrize("backend", ["array", "lazy"]) +def test_cumulative_dtype_override_preserves_current_backend_behavior(backend): + x = blosc2.asarray(np.arange(6, dtype="int8").reshape(2, 3)) + if backend == "lazy": + x = blosc2.LazyExpr((x, None, None)) + expected = np.asarray(x.cumulative_sum(axis=1, dtype="float32")) + expr = blosc2.lazyexpr("x.cumulative_sum(axis=1, dtype='float32')", {"x": x}) + assert expr.dtype == expected.dtype + np.testing.assert_array_equal(expr[:], expected) + + +def test_cumulative_shape_refreshes_after_operand_rebinding(): + expr = blosc2.lazyexpr("x.cumulative_sum(1, None, True)", {"x": blosc2.ones((2, 3))}) + assert expr.shape == (2, 4) + key = next(iter(expr.operands)) + expr.operands[key] = blosc2.ones((3, 5)) + assert expr.shape == (3, 6) + assert expr[:].shape == (3, 6) + + +@pytest.mark.parametrize( + ("text", "shape"), + [ + ("sqrt(x.sum(0, None, True)) + y", (1, 4)), + ("sqrt(np.sum(x, 0, None, None, True)) + y", (1, 4)), + ("x - mean(x, axis=0)", (3, 4)), + ("sum(x[:, 1:] * z, axis=0, keepdims=True)", (1, 3)), + ("sqrt(x.cumulative_sum(1, None, True))", (3, 5)), + ("x[None, 1, 1:] + z", (1, 3)), + ], +) +def test_graph_shape_propagation_is_data_free(text, shape, monkeypatch): + operands = {"x": blosc2.ones((3, 4)), "y": np.ones(4), "z": np.ones(3)} + monkeypatch.setattr(blosc2.NDArray, "__getitem__", lambda *a, **k: pytest.fail("Read data for shape")) + assert parse_expression(text).infer_shape(operands) == shape + + +@pytest.mark.parametrize("backend", ["numpy", "blosc"]) +def test_nested_reduction_shape_matches_execution(backend): + data = np.arange(12.0).reshape(3, 4) + 1 + x = data if backend == "numpy" else blosc2.asarray(data) + args = "0, None, None, True" if backend == "numpy" else "0, None, True" + expr = blosc2.lazyexpr(f"sqrt(x.sum({args})) + y", {"x": x, "y": np.arange(4.0)}) + expected = np.sqrt(data.sum(axis=0, keepdims=True)) + np.arange(4.0) + assert expr.shape == expected.shape + np.testing.assert_allclose(expr[:], expected) + + +def test_graph_shape_unknown_for_data_dependent_index(): + x = np.arange(6) + assert parse_expression("x[mask]").infer_shape({"x": x, "mask": x > 2}) is None + + +def test_graph_shape_does_not_treat_matmul_as_elementwise_broadcast(): + assert parse_expression("x @ y").infer_shape({"x": np.ones((2, 3)), "y": np.ones((3, 4))}) is None + + +@pytest.mark.parametrize("backend", ["numpy", "blosc"]) +def test_nested_indexed_reduction_matches_numpy(backend): + data = np.arange(12.0).reshape(3, 4) + z = np.arange(3.0) + 1 + x = data if backend == "numpy" else blosc2.asarray(data) + expr = blosc2.lazyexpr("sum(x[:, 1:] * z, axis=0, keepdims=True)", {"x": x, "z": z}) + expected = (data[:, 1:] * z).sum(axis=0, keepdims=True) + assert expr.shape == expected.shape + np.testing.assert_allclose(expr[:], expected) + + +def test_nested_shape_rejects_incompatible_broadcast_before_dummy_execution(monkeypatch): + module = importlib.import_module("blosc2.lazyexpr") + monkeypatch.setattr(module, "_numpy_eval_expr", lambda *a, **k: pytest.fail("Dummy inference")) + with pytest.raises(ValueError): + blosc2.lazyexpr("sqrt(sum(x, axis=0)) + y", {"x": blosc2.ones((3, 4)), "y": np.ones(3)}) + + +def test_simpleproxy_refreshes_after_source_resize_and_rebinding(): + source = np.arange(6, dtype="int32") + wrapper = blosc2.SimpleProxy(source) + expr = blosc2.lazyexpr("x + 1", {"x": wrapper}) + source.resize((2, 3), refcheck=False) + assert expr.shape == wrapper.shape == (2, 3) + assert len(wrapper.chunks) == len(wrapper.blocks) == 2 + np.testing.assert_array_equal(expr[:], source + 1) + replacement = np.arange(12.0).reshape(3, 4) + wrapper._src = replacement + assert expr.shape == wrapper.shape == (3, 4) + assert expr.dtype == wrapper.dtype == np.dtype("float64") + np.testing.assert_array_equal(expr[:], replacement + 1) + + +def test_simpleproxy_rejects_rebound_source_before_metadata_hooks(): + wrapper = blosc2.SimpleProxy(np.ones(4)) + expr = blosc2.lazyexpr("x + 1", {"x": wrapper}) + + class HostileSource: + @property + def shape(self): + pytest.fail("Read unadmitted source metadata") + + wrapper._src = HostileSource() + with blosc2.expression_evaluation("full"): + with pytest.raises(blosc2.UnsafeDeserializationError): + _ = expr.shape + with pytest.raises(blosc2.UnsafeDeserializationError): + expr.compute() + + +def test_simpleproxy_rejects_source_cycle_after_construction(): + wrapper = blosc2.SimpleProxy(np.ones(4)) + expr = blosc2.lazyexpr("x + 1", {"x": wrapper}) + wrapper._src = wrapper + with pytest.raises(blosc2.UnsafeDeserializationError, match="cyclic"): + expr.compute() + + +def test_ndfield_refreshes_rebound_parent_layout(): + first = np.zeros(4, dtype=[("x", "int32"), ("y", "int32")]) + field = blosc2.NDField(blosc2.asarray(first), "x") + expr = blosc2.lazyexpr("x + 1", {"x": field}) + replacement = np.zeros(6, dtype=[("y", "int64"), ("x", "float64")]) + replacement["x"] = np.arange(6) + 0.5 + field.ndarr = blosc2.asarray(replacement) + assert expr.shape == (6,) + assert expr.dtype == field.dtype == np.dtype("float64") + assert field.offset == replacement.dtype.fields["x"][1] + np.testing.assert_array_equal(expr[:], replacement["x"] + 1) + + +def test_ndfield_rejects_removed_parent_field_before_computation(): + field = blosc2.NDField(blosc2.asarray(np.zeros(4, dtype=[("x", "int32")])), "x") + expr = blosc2.lazyexpr("x + 1", {"x": field}) + field.ndarr = blosc2.asarray(np.zeros(4, dtype=[("y", "int32")])) + with pytest.raises(ValueError, match="existing structured field"): + _ = expr.dtype + with pytest.raises(ValueError, match="existing structured field"): + expr.compute() + + +@pytest.mark.parametrize( + ("name", "dtype", "backend"), + orthogonal_cases( + ["sqrt", "sin", "exp", "isfinite"], + ["bool", "int8", "uint8", "float32", "float64", "complex64"], + ["numpy", "blosc"], + ), +) +def test_nested_unary_reduction_dtype_matches_execution(name, dtype, backend): + data = (np.arange(12).reshape(3, 4) % 3).astype(dtype) + x = data if backend == "numpy" else blosc2.asarray(data) + expr = blosc2.lazyexpr(f"{name}(x.sum(axis=0, keepdims=True))", {"x": x}) + expected = getattr(np, name)(data.sum(axis=0, keepdims=True)) + assert expr.shape == expected.shape + assert expr.dtype == expected.dtype + np.testing.assert_allclose(expr[:], expected, rtol=1e-6) + + +def test_nested_dtype_inference_never_executes_dummy_reduction(monkeypatch): + data = np.arange(12.0).reshape(4, 3) + module = importlib.import_module("blosc2.lazyexpr") + with monkeypatch.context() as patch: + patch.setattr(module, "_numpy_eval_expr", lambda *a, **k: pytest.fail("Dummy numerical inference")) + expr = blosc2.lazyexpr("sqrt(x.std(axis=0, ddof=2))", {"x": blosc2.asarray(data)}) + assert expr.dtype == np.dtype("float64") + assert expr.shape == (3,) + np.testing.assert_allclose(expr[:], np.sqrt(data.std(axis=0, ddof=2))) + + +def test_nested_dtype_unknown_rules_retain_existing_inference(): + operands = {"x": blosc2.ones((2, 3), dtype="float16"), "y": np.ones(3)} + assert parse_expression("sqrt(x.sum(axis=0))").infer_dtype(operands) is None + assert parse_expression("x + y").infer_dtype(operands) is None + + +def test_reviewed_index_metadata_does_not_allocate_slice_placeholders(monkeypatch): + data = np.arange(12.0).reshape(3, 4) + module = importlib.import_module("blosc2.lazyexpr") + with monkeypatch.context() as patch: + patch.setattr( + module, "extract_and_replace_slices", lambda *a, **k: pytest.fail("Slice placeholders") + ) + patch.setattr(module, "_numpy_eval_expr", lambda *a, **k: pytest.fail("Dummy numerical inference")) + expr = blosc2.lazyexpr("sqrt(x[:, 1:])", {"x": blosc2.asarray(data)}) + assert expr.shape == (3, 3) + assert expr.dtype == np.dtype("float64") + np.testing.assert_allclose(expr[:], np.sqrt(data[:, 1:])) + + +def test_nested_dtype_metadata_refreshes_after_operand_rebinding(): + expr = blosc2.lazyexpr("sin(x.sum(axis=0))", {"x": blosc2.ones((3, 4), dtype="float32")}) + assert expr.dtype == np.dtype("float32") + key = next(iter(expr.operands)) + replacement = np.arange(10.0).reshape(2, 5) + expr.operands[key] = blosc2.asarray(replacement) + assert expr.dtype == np.dtype("float64") + assert expr.shape == (5,) + np.testing.assert_allclose(expr[:], np.sin(replacement.sum(axis=0))) + + +def test_nested_dtype_persistence_without_dummy_ddof_failure(tmp_path): + data = np.arange(12.0).reshape(4, 3) + x = blosc2.asarray(data, urlpath=tmp_path / "x.b2nd", mode="w") + expr = blosc2.lazyexpr("sqrt(x.std(axis=0, ddof=2))", {"x": x}) + expr.save(tmp_path / "expr.b2nd") + opened = blosc2.open(tmp_path / "expr.b2nd") + assert opened.dtype == np.dtype("float64") + assert opened.shape == (3,) + np.testing.assert_allclose(opened[:], np.sqrt(data.std(axis=0, ddof=2))) + + +def test_proxy_rebound_source_rejects_even_with_identical_metadata(monkeypatch): + proxy = blosc2.Proxy(blosc2.ones((6,))) + expr = blosc2.lazyexpr("x + 1", {"x": proxy}) + np.testing.assert_array_equal(expr[:], np.full(6, 2)) + proxy.src = blosc2.full((6,), 7.0) + monkeypatch.setattr(blosc2.Proxy, "fetch", lambda *a, **k: pytest.fail("Fetched rebound source")) + with blosc2.expression_evaluation("full"): + with pytest.raises(ValueError, match="source was rebound"): + expr.compute() + + +def test_proxy_rebound_before_first_admission_rejects(): + proxy = blosc2.Proxy(blosc2.ones((6,))) + proxy.src = blosc2.zeros((6,)) + with pytest.raises(ValueError, match="source was rebound"): + blosc2.lazyexpr("x + 1", {"x": proxy}) + + +def test_proxy_hostile_cache_rejects_before_metadata_hooks(): + proxy = blosc2.Proxy(blosc2.ones((6,))) + expr = blosc2.lazyexpr("x + 1", {"x": proxy}) + + class HostileCache: + @property + def shape(self): + pytest.fail("Read unadmitted cache metadata") + + proxy._cache = HostileCache() + with pytest.raises(blosc2.UnsafeDeserializationError, match="admitted NDArray cache"): + expr.compute() + + +def test_proxy_source_resize_rejects_before_fetch(monkeypatch): + source = blosc2.ones((6,)) + proxy = blosc2.Proxy(source) + expr = blosc2.lazyexpr("x + 1", {"x": proxy}) + source.resize((9,)) + monkeypatch.setattr(blosc2.Proxy, "fetch", lambda *a, **k: pytest.fail("Fetched incompatible source")) + with pytest.raises(ValueError, match="source/cache shape mismatch"): + _ = expr.shape + with pytest.raises(ValueError, match="source/cache shape mismatch"): + expr.compute() + + +@pytest.mark.parametrize("attribute", ["dtype", "chunks", "blocks"]) +def test_proxy_incompatible_cache_rejects_before_fetch(attribute, monkeypatch): + source = blosc2.ones((6,), dtype="float64", chunks=(6,), blocks=(3,)) + proxy = blosc2.Proxy(source) + expr = blosc2.lazyexpr("x + 1", {"x": proxy}) + options = {"dtype": "float64", "chunks": (6,), "blocks": (3,)} + options[attribute] = {"dtype": "float32", "chunks": (3,), "blocks": (2,)}[attribute] + proxy._cache = blosc2.ones((6,), **options) + monkeypatch.setattr(blosc2.Proxy, "fetch", lambda *a, **k: pytest.fail("Fetched incompatible cache")) + with pytest.raises(ValueError, match=f"source/cache {attribute} mismatch"): + expr.compute() + + +def test_proxy_field_metadata_refreshes_after_parent_rebinding(): + from blosc2.proxy import ProxyNDField + + first = blosc2.asarray(np.zeros(4, dtype=[("x", "int32")])) + field = ProxyNDField(blosc2.Proxy(first), "x") + expr = blosc2.lazyexpr("x + 1", {"x": field}) + replacement = np.zeros(6, dtype=[("x", "float64")]) + replacement["x"] = np.arange(6) + 0.5 + field.proxy = blosc2.Proxy(blosc2.asarray(replacement)) + assert expr.shape == field.shape == (6,) + assert expr.dtype == field.dtype == np.dtype("float64") + np.testing.assert_array_equal(expr[:], replacement["x"] + 1) + + +def test_proxy_field_removed_after_parent_rebinding_rejects(): + from blosc2.proxy import ProxyNDField + + first = blosc2.asarray(np.zeros(4, dtype=[("x", "int32")])) + field = ProxyNDField(blosc2.Proxy(first), "x") + expr = blosc2.lazyexpr("x + 1", {"x": field}) + field.proxy = blosc2.Proxy(blosc2.asarray(np.zeros(4, dtype=[("y", "int32")]))) + with pytest.raises(ValueError, match="existing structured field"): + expr.compute() + + +@pytest.mark.parametrize("operation", ["+", "-", "*", "/", "**", "=="]) +@pytest.mark.parametrize( + ("left", "right"), + [ + ("int8", "uint8"), + ("int32", "int32"), + ("int32", "float32"), + ("float32", "float64"), + ("complex64", "float32"), + ], +) +def test_numpy_binary_dtype_rules_match_execution(operation, left, right): + x = np.arange(1, 7, dtype=left).reshape(2, 3) + y = np.full(3, 2, dtype=right) + operations = { + "+": np.add, + "-": np.subtract, + "*": np.multiply, + "/": np.divide, + "**": np.power, + "==": np.equal, + } + expected = operations[operation](x, y) + expr = blosc2.lazyexpr(f"x {operation} y", {"x": x, "y": y}) + assert expr.dtype == expected.dtype + assert expr.shape == expected.shape + np.testing.assert_allclose(expr[:], expected, rtol=1e-6) + + +@pytest.mark.parametrize("scalar", [1, 1.5, 1 + 2j, np.float64(1.5)]) +def test_numpy_weak_vs_concrete_scalar_promotion(scalar): + x = np.arange(6, dtype="float32") + expr = blosc2.lazyexpr("x + y", {"x": x, "y": scalar}) + expected = x + scalar + assert expr.dtype == expected.dtype + np.testing.assert_allclose(expr[:], expected, rtol=1e-6) + + +def test_binary_dtype_inference_is_data_free_and_retains_backend_difference(monkeypatch): + module = importlib.import_module("blosc2.lazyexpr") + data = np.arange(1, 7, dtype="int32") + with monkeypatch.context() as patch: + patch.setattr(module, "_numpy_eval_expr", lambda *a, **k: pytest.fail("Dummy inference")) + expr = blosc2.lazyexpr("x / y", {"x": data, "y": data}) + assert expr.dtype == np.dtype("float64") + x = blosc2.asarray(data) + graph = parse_expression("x / y") + assert graph.infer_dtype({"x": x, "y": x}) is None + expr = blosc2.lazyexpr("x / y", {"x": x, "y": x}) + assert expr.dtype == np.dtype("float32") + + +def test_numpy_weak_integer_range_contract_matches_runtime(): + if np.lib.NumpyVersion(np.__version__) < "2.0.0": + pytest.skip("Menudet follows NumPy 2 weak-scalar overflow diagnostics, not NumPy 1 wrapping") + source = np.ones(3, dtype="int8") + try: + expected = source + 1000 + except OverflowError: + with pytest.raises(OverflowError): + blosc2.lazyexpr("x + 1000", {"x": source}) + else: + expr = blosc2.lazyexpr("x + 1000", {"x": source}) + assert expr.dtype == expected.dtype + np.testing.assert_array_equal(expr[:], expected) + + +def test_numpy_scalar_overflow_retains_existing_fallback(): + assert parse_expression("x + 1e100").infer_dtype({"x": np.ones(3, dtype="float32")}) is None + + +@pytest.mark.parametrize( + "text", + [ + "x.astype('float32')", + "x.astype('float32', 'F', 'safe', True, False)", + "x.astype(dtype='float32', order='C', casting='safe', copy=False)", + "(x + y).astype('float32')", + ], +) +def test_numpy_cast_metadata_matches_execution_without_dummies(text, monkeypatch): + x = np.arange(6, dtype="int8").reshape(2, 3) + module = importlib.import_module("blosc2.lazyexpr") + with monkeypatch.context() as patch: + patch.setattr(module, "_numpy_eval_expr", lambda *a, **k: pytest.fail("Dummy cast")) + expr = blosc2.lazyexpr(text, {"x": x, "y": np.ones(3, dtype="int8")}) + assert expr.shape == x.shape + assert expr.dtype == np.dtype("float32") + expected = (x + 1).astype("float32") if "x + y" in text else x.astype("float32") + np.testing.assert_array_equal(expr[:], expected) + + +@pytest.mark.parametrize( + "text", + [ + "x.astype('float32', 'F', order='C')", + "x.astype('float32', 'Z')", + "x.astype('float32', 'C', 'safe', 1)", + "x.astype('float32', 'C', 'safe', True, 0)", + ], +) +def test_numpy_cast_positional_contract_rejects(text): + with pytest.raises(blosc2.UnsafeDeserializationError): + blosc2.lazyexpr(text, {"x": np.arange(6)}) + + +def test_numpy_cast_unsafe_narrowing_rejects_during_metadata(): + with pytest.raises(TypeError, match="Cannot cast"): + blosc2.lazyexpr("x.astype('int8', casting='safe')", {"x": np.arange(6, dtype="float64")}) + + +def test_flexible_string_cast_does_not_claim_descriptor_width_is_output_width(): + x = np.arange(6, dtype="int64") + assert parse_expression("x.astype('U')").infer_dtype({"x": x}) is None + expr = blosc2.lazyexpr("x.astype('U')", {"x": x}) + assert expr.dtype == x.astype("U").dtype + np.testing.assert_array_equal(expr[:], x.astype("U")) + + +def test_remote_field_closure_rejects_hostile_rebound_records(): + from blosc2.ctable_storage import _RemoteHDF5Field + + field = _RemoteHDF5Field(blosc2.asarray(np.zeros(4, dtype=[("x", "int32")])), "x") + expr = blosc2.lazyexpr("x + 1", {"x": field}) + + class HostileRecords: + @property + def dtype(self): + pytest.fail("Read unadmitted remote records metadata") + + field.records = HostileRecords() + with pytest.raises(blosc2.UnsafeDeserializationError): + expr.compute() + + +def test_remote_field_refresh_preserves_explicit_logical_dtype(): + from blosc2.ctable_storage import _RemoteHDF5Field + + first = blosc2.asarray(np.zeros(4, dtype=[("x", "int32")])) + inherited = _RemoteHDF5Field(first, "x") + overridden = _RemoteHDF5Field(first, "x", dtype="float64") + equal_override = _RemoteHDF5Field(first, "x", dtype="int32") + expr = blosc2.lazyexpr("x + 1", {"x": inherited}) + expr_override = blosc2.lazyexpr("x + 1", {"x": overridden}) + expr_equal_override = blosc2.lazyexpr("x + 1", {"x": equal_override}) + data = np.zeros(6, dtype=[("x", "float32")]) + data["x"] = np.arange(6) + 0.5 + inherited.records = overridden.records = equal_override.records = blosc2.asarray(data) + assert expr.shape == expr_override.shape == (6,) + assert expr.dtype == np.dtype("float32") + assert expr_override.dtype == np.dtype("float64") + assert expr_equal_override.dtype == np.dtype("int32") + np.testing.assert_array_equal(expr[:], data["x"] + 1) + np.testing.assert_array_equal(expr_override[:], data["x"].astype("float64") + 1) + np.testing.assert_array_equal(expr_equal_override[:], data["x"].astype("int32") + 1) + + +@pytest.mark.parametrize("route", ["disk", "frame", "structured"]) +@pytest.mark.parametrize("permission", ["safe", "full"]) +def test_field_persistence_preserves_receiver_and_division_dtype(tmp_path, route, permission): + records = np.zeros(6, dtype=[("x", "int32"), ("y", "int32")]) + records["x"] = np.arange(6) + 1 + records["y"] = 2 + parent = blosc2.asarray(records, urlpath=tmp_path / "records.b2nd", mode="w") + expr = blosc2.lazyexpr("x / y", {"x": blosc2.NDField(parent, "x"), "y": blosc2.NDField(parent, "y")}) + expected = expr[:] + if route == "disk": + expr.save(tmp_path / "expr.b2nd") + reopened = blosc2.open(tmp_path / "expr.b2nd", deserialize=permission) + elif route == "frame": + reopened = blosc2.from_cframe(expr.to_cframe(), deserialize=permission) + else: + module = importlib.import_module("blosc2.b2objects") + reopened = module.decode_b2object_payload( + module.encode_b2object_payload(expr), deserialize=permission + ) + assert reopened.dtype == expr.dtype == np.dtype("float32") + assert all(type(value) is blosc2.NDField for value in reopened.operands.values()) + np.testing.assert_array_equal(reopened[:], expected) + + +def test_field_persistence_uses_relocated_relative_parent_reference(tmp_path): + data = np.zeros(4, dtype=[("x", "float64")]) + data["x"] = np.arange(4) + source = tmp_path / "source" + destination = tmp_path / "destination" + source.mkdir() + parent = blosc2.asarray(data, urlpath=source / "records.b2nd", mode="w") + blosc2.lazyexpr("x + 1", {"x": blosc2.NDField(parent, "x")}).save(source / "expr.b2nd") + source.rename(destination) + reopened = blosc2.open(destination / "expr.b2nd") + np.testing.assert_array_equal(reopened[:], data["x"] + 1) + + +def test_field_persistence_accepts_relative_source_and_carrier_paths(tmp_path, monkeypatch): + monkeypatch.chdir(tmp_path) + directory = tmp_path / "data" + directory.mkdir() + data = np.zeros(4, dtype=[("x", "float64")]) + data["x"] = np.arange(4) + parent = blosc2.asarray(data, urlpath="data/records.b2nd", mode="w") + blosc2.lazyexpr("x + 1", {"x": blosc2.NDField(parent, "x")}).save("data/expr.b2nd") + reopened = blosc2.open("data/expr.b2nd") + np.testing.assert_array_equal(reopened[:], data["x"] + 1) + + +def test_invalid_field_selector_rejects_before_reference_resolution(monkeypatch): + module = importlib.import_module("blosc2.b2objects") + monkeypatch.setattr(blosc2.Ref, "open", lambda *a, **k: pytest.fail("Resolved invalid field recipe")) + payload = { + "kind": "ndfield", + "version": 1, + "field": 1, + "parent": {"kind": "urlpath", "version": 1, "urlpath": "unused"}, + } + with pytest.raises(ValueError, match="selector"): + module.decode_operand_reference(payload) + + +def test_missing_field_parent_keeps_missing_operands_diagnostic(tmp_path): + module = importlib.import_module("blosc2.b2objects") + payload = { + "kind": "lazyexpr", + "version": 1, + "expression": "x + 1", + "operands": { + "x": { + "kind": "ndfield", + "version": 1, + "field": "x", + "parent": {"kind": "urlpath", "version": 1, "urlpath": str(tmp_path / "missing.b2nd")}, + } + }, + } + with pytest.raises(blosc2.exceptions.MissingOperands): + module.decode_b2object_payload(payload) + + +def test_numpy_operand_save_rejects_before_destination_write(tmp_path): + path = tmp_path / "existing" + path.write_bytes(b"unchanged") + x = np.arange(1, 7, dtype="int32") + expr = blosc2.lazyexpr("x / y", {"x": x, "y": x}) + with pytest.raises(ValueError, match="persistent Blosc2"): + expr.save(path) + assert path.read_bytes() == b"unchanged" + + +def test_field_parent_reference_keeps_legacy_proxy_loading_gate(tmp_path, monkeypatch): + records = np.zeros(4, dtype=[("x", "float64")]) + parent = blosc2.asarray(records, urlpath=tmp_path / "records.b2nd", mode="w", meta={"proxy-source": {}}) + expr = blosc2.lazyexpr("x + 1", {"x": blosc2.NDField(parent, "x")}) + expr.save(tmp_path / "expr.b2nd") + module = importlib.import_module("blosc2.schunk") + monkeypatch.setattr( + module, "_reconstruct_legacy_proxy", lambda *a, **k: pytest.fail("Reconstructed legacy proxy") + ) + with pytest.raises(blosc2.UnsafeDeserializationError, match="proxy"): + blosc2.open(tmp_path / "expr.b2nd") + + +@pytest.fixture(params=[blosc2.CachePolicy.NONE, blosc2.CachePolicy.MEMORY, blosc2.CachePolicy.DISK]) +def remote_graph_operand(tmp_path, request): + fsspec = pytest.importorskip("fsspec") + data = np.arange(1, 13, dtype="float64") + url = f"memory:///{tmp_path.name}/array.b2nd" + with fsspec.open(url, "wb") as handle: + handle.write(blosc2.asarray(data).to_cframe()) + options = {"cache_path": tmp_path / "cache.b2nd"} if request.param is blosc2.CachePolicy.DISK else {} + remote = blosc2.RemoteArray(url, cache_policy=request.param, **options) + yield remote, data + remote.close() + + +def test_remote_array_admission_does_not_fetch_data(remote_graph_operand, monkeypatch): + remote, data = remote_graph_operand + with monkeypatch.context() as patch: + patch.setattr(type(remote.src), "get_chunk", lambda *a, **k: pytest.fail("Read during admission")) + expr = blosc2.lazyexpr("sqrt(x)", {"x": remote}) + assert expr.shape == data.shape + assert expr.dtype == data.dtype + np.testing.assert_allclose(expr[:], np.sqrt(data)) + np.testing.assert_allclose(expr[:], np.sqrt(data)) + + +@pytest.mark.parametrize("dependency", ["source", "owner", "proxy", "carrier"]) +def test_remote_array_hostile_dependency_rejects_before_hooks(remote_graph_operand, monkeypatch, dependency): + remote, _ = remote_graph_operand + expr = blosc2.lazyexpr("sqrt(x)", {"x": remote}) + + class HostileDependency: + @property + def dtype(self): + pytest.fail("Read hostile remote dependency metadata") + + @property + def generation(self): + pytest.fail("Read hostile owner generation") + + attribute = {"source": "src", "owner": "_store_owner", "proxy": "_proxy", "carrier": "_carrier"}[ + dependency + ] + with monkeypatch.context() as patch: + patch.setattr(remote, attribute, HostileDependency()) + with pytest.raises(blosc2.UnsafeDeserializationError): + expr.compute() + + +def test_remote_array_same_type_source_rebinding_rejects(remote_graph_operand, monkeypatch): + remote, _ = remote_graph_operand + expr = blosc2.lazyexpr("sqrt(x)", {"x": remote}) + other = blosc2.RemoteArray(remote.urlpath, cache_policy=blosc2.CachePolicy.NONE) + with monkeypatch.context() as patch: + patch.setattr(remote, "src", other.src) + with pytest.raises(ValueError, match="source was rebound"): + expr.compute() + other.close() + + +def test_remote_array_hostile_lock_rejects_before_context_hook(remote_graph_operand, monkeypatch): + remote, _ = remote_graph_operand + expr = blosc2.lazyexpr("sqrt(x)", {"x": remote}) + + class HostileLock: + def __enter__(self): + pytest.fail("Entered hostile remote operation lock") + + with monkeypatch.context() as patch: + patch.setattr(remote, "_operation_lock", HostileLock()) + with pytest.raises(blosc2.UnsafeDeserializationError, match="operation lock"): + expr.compute() + + +def test_remote_array_refresh_keeps_safe_expression_live(remote_graph_operand): + remote, data = remote_graph_operand + expr = blosc2.lazyexpr("sqrt(x)", {"x": remote}) + remote.refresh() + np.testing.assert_allclose(expr[:], np.sqrt(data)) + + +@pytest.mark.skipif(sys.platform in {"emscripten", "wasi"}, reason="Runtime does not provide Python threads") +def test_remote_refresh_serializes_with_active_safe_read(remote_graph_operand, monkeypatch): + remote, data = remote_graph_operand + expr = blosc2.lazyexpr("sqrt(x)", {"x": remote}) + reading, release, refreshing = Event(), Event(), Event() + original = type(remote.src).get_chunk + + def blocked_read(source, *args, **kwargs): + reading.set() + if not release.wait(timeout=10): + raise RuntimeError("Timed out waiting to release the controlled read") + return original(source, *args, **kwargs) + + def refresh(): + refreshing.set() + remote.refresh() + + monkeypatch.setattr(type(remote.src), "get_chunk", blocked_read) + with ThreadPoolExecutor(max_workers=2) as pool: + reader = pool.submit(lambda: expr[:]) + try: + assert reading.wait(timeout=10) + acquired = remote._operation_lock.acquire(blocking=False) + if acquired: + remote._operation_lock.release() + assert not acquired # The active reader owns the serialization lock. + refresher = pool.submit(refresh) + assert refreshing.wait(timeout=10) + assert not refresher.done() + finally: + release.set() + np.testing.assert_allclose(reader.result(timeout=10), np.sqrt(data)) + refresher.result(timeout=10) + np.testing.assert_allclose(expr[:], np.sqrt(data)) + + +def test_remote_array_closed_handle_rejects_before_data(remote_graph_operand, monkeypatch): + remote, _ = remote_graph_operand + expr = blosc2.lazyexpr("sqrt(x)", {"x": remote}) + with monkeypatch.context() as patch: + patch.setattr(remote, "_closed", True) + patch.setattr(type(remote.src), "get_chunk", lambda *a, **k: pytest.fail("Read closed remote")) + with pytest.raises(RuntimeError, match="closed"): + expr.compute() + + +def test_operand_dependent_constructor_does_not_cache_values_between_evaluations(): + source = np.arange(6, dtype="float64") + expr = blosc2.lazyexpr("asarray(x, dtype='float32') + 1", {"x": source}) + np.testing.assert_array_equal(expr[:], source.astype("float32") + 1) + source[:] = np.arange(6) + 10 + np.testing.assert_array_equal(expr[:], source.astype("float32") + 1) + assert expr.cons_cache == {} + + +def test_constant_constructor_cache_rejects_hostile_cached_value(): + expr = blosc2.lazyexpr("ones((6,)) + 1", {}) + np.testing.assert_array_equal(expr[:], np.full(6, 2.0)) + assert expr.cons_cache + + class HostileCache: + @property + def dtype(self): + pytest.fail("Read unadmitted constructor cache metadata") + + expr.cons_cache[next(iter(expr.cons_cache))] = HostileCache() + with pytest.raises(blosc2.UnsafeDeserializationError): + expr.compute() + + +@pytest.mark.parametrize("attribute", ["operands", "_where_args"]) +def test_nested_graph_rejects_hostile_operand_mapping_before_protocols(attribute): + source = blosc2.asarray(np.arange(6, dtype="float64")) + inner = blosc2.lazyexpr("x + 1", {"x": source}) + outer = blosc2.lazyexpr("sqrt(x)", {"x": source}) + outer.operands["x"] = inner + + class HostileMapping: + def __iter__(self): + pytest.fail("Iterated hostile expression mapping") + + def values(self): + pytest.fail("Read hostile expression mapping") + + setattr(inner, attribute, HostileMapping()) + with pytest.raises(blosc2.UnsafeDeserializationError, match="operand mapping"): + outer.compute() + + +@pytest.mark.parametrize("attribute", ["_shape", "_dtype", "chunks", "blocks"]) +def test_simple_proxy_hostile_cached_metadata_rejects_before_hooks(attribute): + proxy = blosc2.SimpleProxy(np.arange(6, dtype="float64")) + expr = blosc2.lazyexpr("sqrt(x)", {"x": proxy}) + + class Hostile: + def __eq__(self, other): + pytest.fail("Compared hostile cached metadata") + + def __iter__(self): + pytest.fail("Iterated hostile cached metadata") + + setattr(proxy, attribute, Hostile()) + with pytest.raises(blosc2.UnsafeDeserializationError): + expr.compute() diff --git a/tests/test_expression_graph_lifetime.py b/tests/test_expression_graph_lifetime.py new file mode 100644 index 000000000..f42e2a237 --- /dev/null +++ b/tests/test_expression_graph_lifetime.py @@ -0,0 +1,229 @@ +"""Container reachability and deterministic concurrent safe-policy probes.""" + +import importlib +import sys +from concurrent.futures import ThreadPoolExecutor +from copy import deepcopy +from threading import Barrier + +import numpy as np +import pytest + +import blosc2 + + +@pytest.mark.parametrize("bad_kind", ["expression", "legacy", "cycle", "depth"]) +def test_inline_recipe_closure_rejects_before_resolving_siblings(monkeypatch, bad_kind): + objects = importlib.import_module("blosc2.b2objects") + reference = blosc2.Ref.urlpath_ref("must-not-open.b2nd").to_dict() + inner = {"kind": "lazyexpr", "version": 1, "expression": "x + 1", "operands": {"x": reference}} + if bad_kind == "expression": + inner["expression"] = "x.__class__" + elif bad_kind == "legacy": + inner["kind"] = "lazyudf" + elif bad_kind == "cycle": + inner["operands"]["x"] = inner + else: + for _ in range(65): + inner = {"kind": "lazyexpr", "version": 1, "expression": "x + 1", "operands": {"x": inner}} + payload = { + "kind": "lazyexpr", + "version": 1, + "expression": "x + y", + "operands": {"x": reference, "y": inner}, + } + monkeypatch.setattr(blosc2.Ref, "open", lambda *a, **k: pytest.fail("Resolved sibling reference")) + with pytest.raises(blosc2.UnsafeDeserializationError): + objects.decode_b2object_payload(payload) + + +def test_shared_inline_recipe_is_not_mistaken_for_a_cycle(tmp_path): + objects = importlib.import_module("blosc2.b2objects") + source = blosc2.asarray(np.arange(4), urlpath=tmp_path / "source.b2nd", mode="w") + inner = { + "kind": "lazyexpr", + "version": 1, + "expression": "x + 1", + "operands": {"x": blosc2.Ref.from_object(source).to_dict()}, + } + payload = {"kind": "lazyexpr", "version": 1, "expression": "x + y", "operands": {"x": inner, "y": inner}} + for recipe in (payload, deepcopy(payload)): + expr = objects.decode_b2object_payload(recipe) + np.testing.assert_array_equal(expr[:], 2 * (np.arange(4) + 1)) + + +@pytest.mark.parametrize("route", ["files", "b2d", "b2z"]) +def test_cross_carrier_reference_cycle_is_bounded(tmp_path, monkeypatch, route): + objects = importlib.import_module("blosc2.b2objects") + path = tmp_path / f"cycle.{route}" + paths = [tmp_path / "first.b2nd", tmp_path / "second.b2nd"] + keys = ["/first", "/second"] + carriers = [] + for index in range(2): + reference = ( + blosc2.Ref.urlpath_ref(str(paths[1 - index])) + if route == "files" + else blosc2.Ref.dictstore_key(str(path), keys[1 - index]) + ) + carrier = objects.make_b2object_carrier("lazyexpr", (4,), np.dtype("float64")) + objects.write_b2object_payload( + carrier, + { + "kind": "lazyexpr", + "version": 1, + "expression": "x + 1", + "operands": {"x": reference.to_dict()}, + }, + ) + carriers.append(carrier) + if route == "files": + for carrier, destination in zip(carriers, paths, strict=True): + carrier.save(destination) + else: + with blosc2.DictStore(path, mode="w") as store: + for key, carrier in zip(keys, carriers, strict=True): + store[key] = carrier + original = blosc2.Ref.open + resolutions = [] + + def resolve(self, **kwargs): + resolutions.append(self) + assert len(resolutions) < 64 + return original(self, **kwargs) + + monkeypatch.setattr(blosc2.Ref, "open", resolve) + + def open_cycle(): + if route == "files": + blosc2.open(paths[0]) + else: + with blosc2.DictStore(path, mode="r") as store: + store[keys[0]] + + with pytest.raises(blosc2.UnsafeDeserializationError, match=r"cyclic|deep"): + open_cycle() + + +@pytest.mark.parametrize( + ("store_name", "suffix"), + [ + ("DictStore", "b2d"), + ("DictStore", "b2z"), + ("TreeStore", "b2d"), + ("TreeStore", "b2z"), + ("EmbedStore", "b2e"), + ], +) +def test_container_forbidden_leaf_rejects_before_reference_resolution( + tmp_path, monkeypatch, store_name, suffix +): + objects = importlib.import_module("blosc2.b2objects") + source = blosc2.asarray(np.arange(4), urlpath=tmp_path / "source.b2nd", mode="w") + expr = blosc2.lazyexpr("x + 1", {"x": source}, evaluation="safe") + payload = objects.encode_b2object_payload(expr) + payload["expression"] = "x.__class__" + carrier = objects.make_b2object_carrier("lazyexpr", source.shape, source.dtype) + objects.write_b2object_payload(carrier, payload) + path = tmp_path / f"forbidden.{suffix}" + cls = getattr(blosc2, store_name) + with cls(str(path), mode="w") as store: + store["/expr"] = carrier + monkeypatch.setattr( + objects, "decode_operand_mapping", lambda *a, **k: pytest.fail("Resolved forbidden leaf operands") + ) + with pytest.raises(blosc2.UnsafeDeserializationError): + with cls(str(path), mode="r", deserialize="safe") as store: + store["/expr"] + + +@pytest.mark.parametrize( + ("store_name", "suffix"), + [ + ("DictStore", "b2d"), + ("DictStore", "b2z"), + ("TreeStore", "b2d"), + ("TreeStore", "b2z"), + ("EmbedStore", "b2e"), + ], +) +@pytest.mark.parametrize("permission", ["safe", "full"]) +@pytest.mark.parametrize("external", [False, True]) +def test_container_leaf_retains_safe_graph_through_composition( + tmp_path, monkeypatch, store_name, suffix, permission, external +): + graph = importlib.import_module("blosc2.expression_graph") + monkeypatch.setattr(graph, "eval", lambda *a, **k: pytest.fail("Python text bridge"), raising=False) + data = np.arange(1, 13, dtype="float64") + source = blosc2.asarray(data, urlpath=tmp_path / "source.b2nd", mode="w") + expr = blosc2.lazyexpr("sqrt(x) - mean(x)", {"x": source}, evaluation="safe") + path = tmp_path / f"container.{suffix}" + cls = getattr(blosc2, store_name) + options = {"threshold": 0 if external else 2**30} if store_name != "EmbedStore" else {} + with monkeypatch.context() as patch: + patch.setattr(blosc2.LazyExpr, "compute", lambda *a, **k: pytest.fail("Materialized during storage")) + patch.setattr(blosc2.LazyExpr, "__getitem__", lambda *a, **k: pytest.fail("Read during storage")) + with cls(str(path), mode="w", **options) as store: + store["/expr"] = expr + with cls(str(path), mode="r", deserialize=permission) as store: + opened = store["/expr"] + assert type(opened) is blosc2.LazyExpr + with blosc2.expression_evaluation("full"): + np.testing.assert_allclose(opened[:], np.sqrt(data) - data.mean()) + combined = np.square(opened + 1) + assert combined._evaluation == "safe" + np.testing.assert_allclose(combined[:3], (np.sqrt(data[:3]) - data.mean() + 1) ** 2) + + +@pytest.mark.skipif(sys.platform in {"emscripten", "wasi"}, reason="Runtime does not provide Python threads") +def test_shared_graph_thread_policy_isolation(tmp_path, monkeypatch): + graph = importlib.import_module("blosc2.expression_graph") + monkeypatch.setattr(graph, "eval", lambda *a, **k: pytest.fail("Python text bridge"), raising=False) + data = np.arange(1, 65, dtype="float64") + source = blosc2.asarray(data, urlpath=tmp_path / "source.b2nd", mode="w") + expr = blosc2.lazyexpr("x - mean(x)", {"x": source}, evaluation="safe") + expr.save(tmp_path / "expr.b2nd") + opened = blosc2.open(tmp_path / "expr.b2nd") + barrier = Barrier(4) + + def evaluate(index): + mode = "full" if index % 2 else "safe" + with blosc2.expression_evaluation(mode): + barrier.wait(timeout=10) + for _ in range(3): + combined = opened + index + assert combined._evaluation == "safe" + np.testing.assert_array_equal(combined[:], data - data.mean() + index) + assert graph.evaluation_mode() == mode + + with ThreadPoolExecutor(max_workers=4) as pool: + list(pool.map(evaluate, range(4))) + assert graph.evaluation_mode() == "full" + + +@pytest.mark.parametrize("suffix", ["b2d", "b2z"]) +@pytest.mark.parametrize("permission", ["safe", "full"]) +@pytest.mark.parametrize("external", [False, True]) +def test_nested_tree_reference_graph_survives_subtree_and_shared_operands( + tmp_path, monkeypatch, suffix, permission, external +): + objects = importlib.import_module("blosc2.b2objects") + graph = importlib.import_module("blosc2.expression_graph") + path = tmp_path / f"mixed.{suffix}" + data = np.arange(1, 9, dtype="float64") + reference = blosc2.Ref.dictstore_key(str(path), "/arrays/data").to_dict() + inner = {"kind": "lazyexpr", "version": 1, "expression": "sqrt(x)", "operands": {"x": reference}} + payload = {"kind": "lazyexpr", "version": 1, "expression": "x + y", "operands": {"x": inner, "y": inner}} + carrier = objects.make_b2object_carrier("lazyexpr", data.shape, data.dtype) + objects.write_b2object_payload(carrier, payload) + with blosc2.TreeStore(path, mode="w", threshold=0 if external else 2**30) as store: + store["/arrays/data"] = blosc2.asarray(data) + store["/arrays/other"] = blosc2.asarray(np.arange(3, dtype="int32")) + store["/queries/deep/expr"] = carrier + monkeypatch.setattr(graph, "eval", lambda *a, **k: pytest.fail("Python text bridge"), raising=False) + with blosc2.TreeStore(path, mode="r", deserialize=permission) as store: + subtree = store["/queries"] + opened = subtree["/deep"]["/expr"] + assert opened._evaluation == "safe" + with blosc2.expression_evaluation("full"): + np.testing.assert_allclose(opened[1:4], 2 * np.sqrt(data[1:4])) + np.testing.assert_allclose(np.square(opened + 1)[:], (2 * np.sqrt(data) + 1) ** 2) diff --git a/tests/test_expression_graph_properties.py b/tests/test_expression_graph_properties.py new file mode 100644 index 000000000..983a6888d --- /dev/null +++ b/tests/test_expression_graph_properties.py @@ -0,0 +1,342 @@ +"""Deterministic differential and lifetime probes for the experimental boundary.""" + +import gc +import importlib +import warnings +import weakref + +import numpy as np +import pytest + +import blosc2 +from conftest import orthogonal_cases + + +@pytest.mark.parametrize( + ("source_dtype", "target_dtype", "casting"), + orthogonal_cases( + ["bool", "int8", "uint8", "int32", "float16", "float32", "float64", "complex64", "complex128"], + ["int32", "float32", "float64", "complex64"], + ["unsafe", "same_kind", "safe"], + ), +) +def test_numpy_cast_corner_values_errors_and_warnings(source_dtype, target_dtype, casting): + source = np.arange(1, 5).astype(source_dtype) + text = f"x.astype('{target_dtype}', casting='{casting}')" + with warnings.catch_warnings(record=True) as expected_warnings: + warnings.simplefilter("always") + try: + expected = source.astype(target_dtype, casting=casting) + except TypeError: + with pytest.raises(TypeError): + blosc2.lazyexpr(text, {"x": source}, evaluation="safe") + return + with warnings.catch_warnings(record=True) as actual_warnings: + warnings.simplefilter("always") + expr = blosc2.lazyexpr(text, {"x": source}, evaluation="safe") + result = expr[:] + assert expr.dtype == expected.dtype + np.testing.assert_array_equal(result, expected) + assert {item.category for item in actual_warnings} == {item.category for item in expected_warnings} + + +def test_value_dependent_numpy_promotion_defers_scalar_metadata(monkeypatch): + module = importlib.import_module("blosc2.expression_graph") + monkeypatch.setattr(module, "_NUMPY_VALUE_PROMOTION", True) + x = np.arange(4, dtype="uint8") + graph = module.parse_expression("x + scalar") + assert graph.infer_dtype({"x": x, "scalar": 256}) is None + assert graph.infer_dtype({"x": x, "scalar": np.array(256)}) is None + assert graph.infer_dtype({"x": x, "scalar": x}) == np.dtype("uint8") + + +@pytest.mark.parametrize("name", ["sum", "prod", "argmin", "argmax", "cumulative_sum", "cumulative_prod"]) +def test_platform_accumulator_fallback_uses_numpy_integer_width(monkeypatch, name): + module = importlib.import_module("blosc2.expression_graph") + monkeypatch.setattr(module, "_BLOSC_PLATFORM_ACCUMULATOR_FALLBACK", True) + source = blosc2.asarray(np.arange(1, 5, dtype="int8")) + graph = module.parse_expression(f"x.{name}(axis=0)") + expected = blosc2.DEFAULT_INDEX if name in {"argmin", "argmax"} else np.intp + assert graph.infer_dtype({"x": source}) == np.dtype(expected) + numpy_graph = module.parse_expression("np.sum(x)") + assert numpy_graph.infer_dtype({"x": np.arange(4, dtype="int8")}) == np.dtype(np.intp) + + +@pytest.mark.parametrize( + ("order", "copy", "subok", "positional"), + orthogonal_cases(["C", "F", "A", "K"], [False, True], [False, True], [False, True]), +) +def test_numpy_cast_layout_signature_and_nested_reduction(order, copy, subok, positional): + source = np.asfortranarray(np.arange(1, 13, dtype="int16").reshape(3, 4)) + source = source[:, ::-1] + arguments = ( + f"'float32', {order!r}, 'safe', {subok}, {copy}" + if positional + else f"dtype='float32', order={order!r}, casting='safe', subok={subok}, copy={copy}" + ) + expected = source.astype("float32", order=order, casting="safe", subok=subok, copy=copy) + expr = blosc2.lazyexpr(f"x.astype({arguments}).sum(axis=0)", {"x": source}, evaluation="safe") + assert expr.shape == (4,) + assert expr.dtype == expected.sum(axis=0).dtype + np.testing.assert_array_equal(expr[:], expected.sum(axis=0)) + # Scheduling may return independent storage; no aliasing/order guarantee is + # added to LazyExpr merely because an intermediate NumPy cast uses copy=False. + + +@pytest.mark.parametrize("dtype", ["int32", "float32", "float64"]) +@pytest.mark.parametrize( + "text", + [ + "(x + y).sum(axis=0, keepdims=True)", + "(x / y).mean(axis=1)", + "sum(x + y, axis=1)", + ], +) +def test_numpy_intermediate_reduction_metadata_without_execution(monkeypatch, dtype, text): + module = importlib.import_module("blosc2.lazyexpr") + operands = {"x": np.arange(1, 33, dtype=dtype).reshape(4, 8), "y": np.full((4, 8), 2, dtype=dtype)} + trusted = blosc2.lazyexpr(text, operands, evaluation="full") + expected = trusted[:] + with monkeypatch.context() as patch: + patch.setattr(module, "_numpy_eval_expr", lambda *a, **k: pytest.fail("Dummy numerical inference")) + safe = blosc2.lazyexpr(text, operands, evaluation="safe") + assert safe.shape == trusted.shape + assert safe.dtype == trusted.dtype + np.testing.assert_allclose(safe[:], expected, rtol=2e-6, atol=2e-6) + + +@pytest.mark.parametrize("cast", [False, True]) +def test_numpy_intermediate_extended_contracts_without_dummies(monkeypatch, cast): + module = importlib.import_module("blosc2.lazyexpr") + x = np.arange(1, 33, dtype="float32").reshape(4, 8) + y = np.full_like(x, 2) + # The trusted validator/inference does not support these forms. Compare + # the explicit NumPy contract rather than calling that a parity success. + text = "(x + y).astype('float64').sum(axis=0)" if cast else "np.std(x + y, axis=0, ddof=1)" + expected = (x + y).astype("float64").sum(axis=0) if cast else np.std(x + y, axis=0, ddof=1) + with monkeypatch.context() as patch: + patch.setattr(module, "_numpy_eval_expr", lambda *a, **k: pytest.fail("Dummy numerical inference")) + safe = blosc2.lazyexpr(text, {"x": x, "y": y}, evaluation="safe") + assert safe.shape == expected.shape + assert safe.dtype == expected.dtype + np.testing.assert_allclose(safe[:], expected, rtol=2e-6, atol=2e-6) + + +@pytest.mark.parametrize("fails", [False, True]) +def test_graph_evaluation_releases_operands_without_cyclic_gc(fails): + from blosc2.expression_graph import parse_expression + + graph = parse_expression("reshape(x, (3,))" if fails else "sqrt(x) + 1") + enabled = gc.isenabled() + gc.disable() + try: + source = np.arange(4, dtype="float64") + reference = weakref.ref(source) + if fails: + with pytest.raises(ValueError): + graph.evaluate({"x": source}) + else: + result = graph.evaluate({"x": source}) + np.testing.assert_allclose(result, np.sqrt(source) + 1) + del source + assert reference() is None + finally: + if enabled: + gc.enable() + + +@pytest.mark.parametrize( + ("backends", "dtype", "text"), + orthogonal_cases( + [("numpy", "numpy"), ("numpy", "blosc2"), ("blosc2", "numpy"), ("blosc2", "blosc2")], + ["int32", "float32", "float64"], + [ + "(x + y).sum(axis=0)", + "(x / y).mean(axis=1)", + "sum(sqrt(x) + y, axis=0)", + "sqrt(x + y) - mean(y)", + "(x + y).std(axis=1)", + "(x + y).var(axis=1)", + ], + ), +) +def test_mixed_backend_intermediates_match_trusted_contract(backends, dtype, text): + left_backend, right_backend = backends + data = np.arange(1, 33, dtype=dtype).reshape(4, 8) + other = np.full((4, 8), 2, dtype=dtype) + operands = { + "x": data if left_backend == "numpy" else blosc2.asarray(data), + "y": other if right_backend == "numpy" else blosc2.asarray(other), + } + trusted = blosc2.lazyexpr(text, operands, evaluation="full") + safe = blosc2.lazyexpr(text, operands, evaluation="safe") + assert safe.shape == trusted.shape + assert safe.dtype == trusted.dtype + np.testing.assert_allclose(safe[:], trusted[:], rtol=2e-6, atol=2e-6) + + +@pytest.mark.parametrize( + ("backend", "dtype", "literal"), + orthogonal_cases( + ["numpy", "blosc2"], ["int8", "uint8", "int32", "float32", "float64"], ["1", "0.5", "128", "256"] + ) + + [("numpy", "uint8", "256"), ("blosc2", "uint8", "256")], +) +def test_weak_scalar_value_and_error_contract_matches_trusted(backend, dtype, literal): + if np.lib.NumpyVersion(np.__version__) < "2.0.0": + pytest.skip("Menudet follows NumPy 2 weak-scalar overflow diagnostics, not NumPy 1 wrapping") + data = np.arange(1, 5, dtype=dtype) + operands = {"x": data if backend == "numpy" else blosc2.asarray(data)} + + def evaluate(mode): + try: + expr = blosc2.lazyexpr(f"x + {literal}", operands, evaluation=mode) + return expr.dtype, expr[:], None + except OverflowError as error: + return None, None, type(error) + + trusted_dtype, trusted_values, trusted_error = evaluate("full") + safe_dtype, safe_values, safe_error = evaluate("safe") + assert safe_error == trusted_error + if trusted_error is None: + assert safe_dtype == trusted_dtype + np.testing.assert_array_equal(safe_values, trusted_values) + + +def numerical_case(seed, x, y): + rng = np.random.default_rng(seed) + text, expected = "x", x + for _ in range(3): + operation = int(rng.integers(4)) + if operation == 0: + text, expected = f"sqrt(({text}) * ({text}) + 1)", np.sqrt(expected * expected + 1) + elif operation == 1: + text, expected = f"sin({text})", np.sin(expected) + elif operation == 2: + text, expected = f"(({text}) + y)", expected + y + else: + text, expected = f"(({text}) * 0.5)", expected * 0.5 + reduction = seed % 4 + if reduction == 0: + return f"sum({text}, axis=0, keepdims=True)", expected.sum(axis=0, keepdims=True) + if reduction == 1: + return f"mean({text}, axis=1)", expected.mean(axis=1) + if reduction == 2: + return f"(({text}) - mean(x))", expected - x.mean() + return text, expected + + +@pytest.mark.parametrize( + ("seed", "dtype", "route"), + orthogonal_cases(range(8), ["float32", "float64"], ["disk", "frame", "structured"]), +) +def test_seeded_persisted_graph_lifetime_without_python_text_bridge( + tmp_path, monkeypatch, seed, dtype, route +): + graph_module = importlib.import_module("blosc2.expression_graph") + x = np.linspace(1, 3, 32, dtype=dtype).reshape(4, 8) + y = np.linspace(0.25, 0.5, 8, dtype=dtype) + text, expected = numerical_case(seed, x, y) + source = blosc2.asarray(x, urlpath=tmp_path / "x.b2nd", mode="w") + other = blosc2.asarray(y, urlpath=tmp_path / "y.b2nd", mode="w") + # NumExpr/Blosc2 accumulation need not share NumPy's intermediate dtype. + # Capture the existing trusted contract before disabling the text bridge. + trusted = blosc2.lazyexpr(text, {"x": source, "y": other}, evaluation="full") + expected_dtype = trusted.dtype + monkeypatch.setattr( + graph_module, "eval", lambda *a, **k: pytest.fail("Reached Python text bridge"), raising=False + ) + expr = blosc2.lazyexpr(text, {"x": source, "y": other}, evaluation="safe") + if route == "disk": + expr.save(tmp_path / "expr.b2nd") + opened = blosc2.open(tmp_path / "expr.b2nd") + elif route == "frame": + opened = blosc2.from_cframe(expr.to_cframe()) + else: + objects = importlib.import_module("blosc2.b2objects") + opened = objects.decode_b2object_payload(objects.encode_b2object_payload(expr)) + with blosc2.expression_evaluation("full"): + assert opened.shape == expected.shape + assert opened.dtype == expected_dtype + np.testing.assert_allclose(opened[:], expected, rtol=2e-6, atol=2e-6) + np.testing.assert_allclose(opened[:1], expected[:1], rtol=2e-6, atol=2e-6) + combined = np.square(opened + 1) + np.testing.assert_allclose(combined[:], np.square(expected + 1), rtol=4e-6, atol=4e-6) + source[:] = x + 0.25 + _, changed = numerical_case(seed, x + 0.25, y) + np.testing.assert_allclose(opened[:], changed, rtol=2e-6, atol=2e-6) + + +@pytest.mark.parametrize("text", ["sqrt(x) + 1", "sum(sqrt(x))", "x - mean(x)"]) +def test_partial_result_does_not_coerce_whole_source_to_numpy(monkeypatch, text): + graph_module = importlib.import_module("blosc2.expression_graph") + monkeypatch.setattr( + graph_module, "eval", lambda *a, **k: pytest.fail("Python text bridge"), raising=False + ) + data = np.linspace(1, 4, 8192) + source = blosc2.asarray(data, chunks=(256,), blocks=(64,)) + original_array = getattr(blosc2.NDArray, "__array__", None) + original_getitem = blosc2.NDArray.__getitem__ + original_slice = blosc2.NDArray.get_slice_numpy + original_decompress = blosc2.SChunk.decompress_chunk + source_schunk = source.schunk + reads = [] + + def array(self, *args, **kwargs): + if self is source: + pytest.fail("Whole-source NumPy coercion") + if original_array is not None: + return original_array(self, *args, **kwargs) + return np.asarray(original_getitem(self, ()), *args, **kwargs) + + def getitem(self, item): + result = original_getitem(self, item) + if self is source and type(result) is np.ndarray: + reads.append(result.size) + assert result.size <= source.chunks[0] + return result + + def get_slice_numpy(self, buffer, key): + if self is source: + reads.append(buffer.size) + assert buffer.size <= source.chunks[0] + return original_slice(self, buffer, key) + + def decompress_chunk(self, nchunk, dst=None): + result = original_decompress(self, nchunk, dst) + if self is source_schunk: + nbytes = len(result) if dst is None else memoryview(dst).nbytes + assert nbytes <= source.chunks[0] * source.dtype.itemsize + reads.append(nbytes // source.dtype.itemsize) + return result + + monkeypatch.setattr(blosc2.NDArray, "__array__", array, raising=False) + monkeypatch.setattr(blosc2.NDArray, "__getitem__", getitem) + monkeypatch.setattr(blosc2.NDArray, "get_slice_numpy", get_slice_numpy) + monkeypatch.setattr(blosc2.SChunk, "decompress_chunk", decompress_chunk) + expr = blosc2.lazyexpr(text, {"x": source}, evaluation="safe") + if text == "sum(sqrt(x))": + np.testing.assert_allclose(expr[()], np.sqrt(data).sum()) + else: + expected = np.sqrt(data) + 1 if text == "sqrt(x) + 1" else data - data.mean() + np.testing.assert_allclose(expr[17:41], expected[17:41]) + # This probes Python-visible reads, not all native allocations or schedules. + assert not reads or max(reads) <= 256 + + +@pytest.mark.parametrize("seed", range(6)) +def test_bounded_forbidden_syntax_variations_reject_before_resolution(monkeypatch, seed): + objects = importlib.import_module("blosc2.b2objects") + monkeypatch.setattr( + objects, "decode_operand_mapping", lambda *a, **k: pytest.fail("Resolved forbidden graph") + ) + forbidden = [ + f"x.__getattribute__('shape{seed}')", + f"[x for x in range({seed + 1})]", + f"(lambda x: x + {seed})(x)", + f"unknown_{seed}(x)", + f"sum(x, **options_{seed})", + f"np.lib.function_{seed}(x)", + ] + with pytest.raises((blosc2.UnsafeDeserializationError, ValueError)): + objects.decode_structured_lazyexpr({"expression": forbidden[seed % len(forbidden)], "operands": {}}) diff --git a/tests/test_numexpr_threads.py b/tests/test_expression_threads.py similarity index 52% rename from tests/test_numexpr_threads.py rename to tests/test_expression_threads.py index 9d162ff3c..43e3b55dd 100644 --- a/tests/test_numexpr_threads.py +++ b/tests/test_expression_threads.py @@ -5,6 +5,7 @@ # SPDX-License-Identifier: BSD-3-Clause ####################################################################### +import json import os import subprocess import sys @@ -14,22 +15,32 @@ import blosc2 -def test_numexpr_max_threads_no_warning(): - """Test that importing blosc2 with NUMEXPR_MAX_THREADS set does not produce a warning. - - When NUMEXPR_MAX_THREADS is set to a value lower than the number of threads - blosc2 would use, we should NOT call numexpr.set_num_threads() to avoid - the numexpr warning being printed to stderr. - """ +def test_numexpr_environment_does_not_control_blosc_threads(): + """Legacy NumExpr environment variables do not control Blosc2 workers.""" # Inherit the current environment but set NUMEXPR_MAX_THREADS to a low value if blosc2.IS_WASM: pytest.skip("subprocess is not supported on emscripten/wasm32") env = os.environ.copy() env["NUMEXPR_MAX_THREADS"] = "1" + env["NUMEXPR_NUM_THREADS"] = "1" result = subprocess.run( - [sys.executable, "-c", "import blosc2; print(blosc2.__version__)"], + [ + sys.executable, + "-S", + "-c", + "import sys,json,importlib.util; sys.path[:]=json.loads(sys.argv[1]); " + "package=json.loads(sys.argv[2]); " + "spec=importlib.util.spec_from_file_location('blosc2',package['origin'], " + "submodule_search_locations=package['paths']); " + "blosc2=importlib.util.module_from_spec(spec); sys.modules['blosc2']=blosc2; " + "spec.loader.exec_module(blosc2); " + "blosc2.set_nthreads(2); assert blosc2.nthreads==2; " + "assert blosc2.numexpr is None; assert 'numexpr' not in sys.modules", + json.dumps(sys.path), + json.dumps({"origin": blosc2.__file__, "paths": list(blosc2.__path__)}), + ], capture_output=True, text=True, env=env, diff --git a/tests/test_http_server_diagnostics.py b/tests/test_http_server_diagnostics.py new file mode 100644 index 000000000..8f8be1d4f --- /dev/null +++ b/tests/test_http_server_diagnostics.py @@ -0,0 +1,25 @@ +"""HTTP request failures retain their exception line even when tests pass.""" + +import pytest + +from conftest import report_http_server_error + + +@pytest.mark.parametrize("error", [ConnectionResetError("client disconnected"), ValueError("handler bug")]) +def test_http_server_error_includes_summary_context_and_traceback(tmp_path, monkeypatch, capsys, error): + log_path = tmp_path / "http-errors.log" + monkeypatch.setenv("PYTEST_CURRENT_TEST", "example_test (call)") + try: + raise error + except type(error): + report_http_server_error(log_path, ("127.0.0.1", 12345)) + output = capsys.readouterr().err + summary = f"{type(error).__name__}: {error}" + assert output.startswith(f"HTTP request error: {summary}\n") + assert "Test: example_test (call)" in output + assert "Client: ('127.0.0.1', 12345)" in output + assert "Traceback (most recent call last):" in output + assert f"Full HTTP error log: {log_path}" in output + saved = log_path.read_text(encoding="utf-8") + assert saved in output + assert saved.rstrip().endswith(summary) diff --git a/tests/test_lazyexpr_output_dispatch.py b/tests/test_lazyexpr_output_dispatch.py new file mode 100644 index 000000000..8f37ff510 --- /dev/null +++ b/tests/test_lazyexpr_output_dispatch.py @@ -0,0 +1,266 @@ +"""Eligible LazyExpr execution follows the requested output storage.""" + +import importlib + +import numpy as np +import pytest + +import blosc2 + + +@pytest.fixture(autouse=True) +def prefilter_runtime(native_graph_runtime): + if blosc2.IS_WASM or not blosc2.blosc2_ext.portable_prefilter_available(): + pytest.skip("Native compressed prefilters require a host runtime") + from blosc2.graph_plan import NativeGraph + + if not NativeGraph.from_expression("x + 1", {"x": "float64"}, jit=True).has_jit: + pytest.skip("Automatic output dispatch requires a native JIT") + + +@pytest.fixture +def parallel_threads(): + # Other modules can leave the process-wide codec thread count at one. + # A test requiring the parallel map must establish and restore its policy. + previous = blosc2.set_nthreads(2) + try: + yield + finally: + blosc2.set_nthreads(previous) + + +def operands(size=257, dtype="float64"): + x = np.linspace(0, 1, size, dtype=dtype) + y = np.linspace(1, 2, size, dtype=dtype) + return { + "x": blosc2.asarray(x, chunks=(128,), blocks=(32,)), + "y": blosc2.asarray(y, chunks=(128,), blocks=(32,)), + }, x + (y - 1) + + +def forbid_fallback(monkeypatch): + def forbidden(*args, **kwargs): + pytest.fail("Native output dispatch used a numerical fallback") + + monkeypatch.setattr(importlib.import_module("blosc2.lazyexpr"), "ne_evaluate", forbidden) + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + return forbidden + + +@pytest.mark.parametrize("mode", ["full", "safe"]) +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("explicit_grid", [False, True]) +def test_blosc2_output_native_prefilter(monkeypatch, mode, dtype, explicit_grid): + inputs, expected = operands(dtype=dtype) + with blosc2.expression_evaluation(mode): + expr = blosc2.lazyexpr("x + (y - 1)", inputs) + forbidden = forbid_fallback(monkeypatch) + options = {"cparams": {"clevel": 0}} + if explicit_grid: + options.update(chunks=(128,), blocks=(32,)) + with monkeypatch.context() as patch: + patch.setattr(blosc2.NDArray, "__getitem__", forbidden) + first = expr.compute(**options) + patch.setattr(blosc2.NativeGraph, "from_expression", forbidden) + patch.setattr(blosc2.NativeGraph, "__init__", forbidden) + second = expr.compute(**options) + assert first is not second + assert first.chunks == (128,) + assert first.blocks == (32,) + assert first.cparams.clevel == 0 + np.testing.assert_array_equal(first[:], expected) + report = expr._native_execution_report + assert report["route"] == "portable-prefilter" + assert report["input_materialization_bytes"] == 0 + assert report["output_copy_bytes"] == 0 + + +@pytest.mark.parametrize("bound", [False, True]) +def test_matching_blosc2_out_and_evaluate(monkeypatch, bound): + inputs, expected = operands() + output = blosc2.uninit(expected.shape, chunks=(128,), blocks=(32,), cparams={"clevel": 0}) + expr = blosc2.lazyexpr("x + (y - 1)", inputs, **({"out": output} if bound else {})) + forbid_fallback(monkeypatch) + result = expr.compute(**({} if bound else {"out": output})) + assert result is output + assert expr._native_execution_report["route"] == "portable-prefilter" + np.testing.assert_array_equal(result[:], expected) + assert blosc2.evaluate("x + (y - 1)", local_dict=inputs, out=output) is output + + +@pytest.mark.parametrize("explicit_out", [False, True]) +@pytest.mark.parametrize("bound", [False, True]) +def test_numpy_output_native_parallel_map(monkeypatch, parallel_threads, explicit_out, bound): + from blosc2 import native_graph, resident_execution + + monkeypatch.setattr(native_graph, "MINIMUM_COMPRESSED_MAP_ITEMS", 1) + monkeypatch.setattr(native_graph, "MINIMUM_COMPRESSED_GRAPH_ITEMS", 1) + monkeypatch.setattr(resident_execution, "MINIMUM_WORKER_ITEMS", 16384) + inputs, expected = operands(size=200003) + output = np.empty_like(expected) + expr = blosc2.lazyexpr("x + (y - 1)", inputs, **({"out": output} if explicit_out and bound else {})) + forbid_fallback(monkeypatch) + if explicit_out: + result = expr.compute(**({} if bound else {"out": output})) + assert result is output + else: + result = expr[:] + assert isinstance(result, np.ndarray) + np.testing.assert_array_equal(result, expected) + assert expr._native_execution_report["route"] == "portable-prefilter" + + +@pytest.mark.parametrize("clevel", [0, 1]) +@pytest.mark.parametrize("explicit_out", [False, True]) +def test_resident_inputs_use_stored_prefilter(monkeypatch, parallel_threads, clevel, explicit_out): + bounds = np.iinfo("int64") + values = np.resize(np.array([bounds.min, bounds.max, 0, 1], dtype="int64"), 1027) + other = values[::-1].copy() + expected = values + (other - 1) + inputs = {"x": values, "y": other} + expr = blosc2.lazyexpr("x + (y - 1)", inputs) + options = {"chunks": (256,), "blocks": (64,), "cparams": {"clevel": clevel, "nthreads": 2}} + output = blosc2.uninit(values.shape, dtype=values.dtype, **options) if explicit_out else None + forbid_fallback(monkeypatch) + result = expr.compute(out=output) if explicit_out else expr.compute(**options) + assert isinstance(result, blosc2.NDArray) + if explicit_out: + assert result is output + assert result.chunks == (256,) + assert result.blocks == (64,) + assert result.cparams.clevel == clevel + np.testing.assert_array_equal(result[:], expected) + report = expr._native_execution_report + assert report["route"] == "portable-prefilter" + assert report["input_buffer_allocations"] == report["native_decoder_contexts"] == 0 + assert report["input_materialization_bytes"] == report["output_copy_bytes"] == 0 + tail = np.frombuffer(result.schunk.decompress_chunk(result.schunk.nchunks - 1), dtype=values.dtype) + np.testing.assert_array_equal(tail[3:], 0) + + +def test_resident_stored_prefilter_failure_is_not_replayed(monkeypatch): + values = np.arange(257.0) + expr = blosc2.lazyexpr("x + 1", {"x": values}) + forbid_fallback(monkeypatch) + + def failure(*args, **kwargs): + raise OSError("Stored prefilter failed") + + monkeypatch.setattr(blosc2.NDArray, "_execute_portable_prefilter", failure) + with pytest.raises(OSError, match="Stored prefilter failed"): + expr.compute() + + +def test_resident_stored_prefilter_options_and_rebinding(monkeypatch, tmp_path): + values = np.arange(1027.0) + expr = blosc2.lazyexpr("x + 1", {"x": values}) + params = blosc2.CParams(codec=blosc2.Codec.LZ4, clevel=1, nthreads=2) + path = tmp_path / "resident-prefilter.b2nd" + forbid_fallback(monkeypatch) + first = expr.compute( + chunks=(256,), blocks=(64,), cparams=params, urlpath=path, meta={"sink": "resident"} + ) + assert params.clevel == 1 + assert params.nthreads == 2 + assert first.schunk.meta["sink"] == "resident" + np.testing.assert_array_equal(blosc2.open(path)[:], values + 1) + values += 10 + second = expr.compute(chunks=(256,), blocks=(64,), cparams=params) + np.testing.assert_array_equal(second[:], values + 1) + np.testing.assert_array_equal(first[:], values - 9) + + +def test_resident_numpy_out_avoids_full_result_allocation(monkeypatch, parallel_threads): + values = np.arange(300003, dtype="int64") + inputs = {"x": values, "y": values[::-1].copy()} + expected = values + (inputs["y"] - 1) + output = np.empty_like(values) + expr = blosc2.lazyexpr("x + (y - 1)", inputs) + expr.compute(out=output) # Prepare artifacts and workers before instrumentation. + original_empty = np.empty + + def bounded_empty(shape, *args, **kwargs): + dtype = np.dtype(kwargs.get("dtype", args[0] if args else "float64")) + if shape == values.shape and dtype.itemsize: + pytest.fail("Explicit resident out allocated a full-size temporary") + return original_empty(shape, *args, **kwargs) + + def forbidden_copy(*args, **kwargs): + pytest.fail("Explicit resident out copied a full-size result") + + monkeypatch.setattr(np, "empty", bounded_empty) + monkeypatch.setattr(np, "copyto", forbidden_copy) + assert expr.compute(out=output) is output + np.testing.assert_array_equal(output, expected) + assert expr._native_execution_report["output_copy_bytes"] == 0 + assert blosc2.evaluate("x + (y - 1)", local_dict=inputs, out=output) is output + np.testing.assert_array_equal(output, expected) + + +def test_native_prefilter_storage_options_and_rebinding(tmp_path): + inputs, expected = operands() + expr = blosc2.lazyexpr("x + (y - 1)", inputs) + path = tmp_path / "expr.b2nd" + first = expr.compute(cparams={"clevel": 5}, urlpath=path, meta={"test": "native"}) + assert first.cparams.clevel == 5 + assert first.schunk.meta["test"] == "native" + np.testing.assert_array_equal(blosc2.open(path)[:], expected) + inputs["x"][:] = inputs["x"][:] + 10 + second = expr.compute(cparams={"clevel": 0}) + np.testing.assert_allclose(second[:], expected + 10, rtol=1e-15) + np.testing.assert_array_equal(first[:], expected) + + +@pytest.mark.parametrize("partial", [False, True]) +def test_other_grids_and_partial_selection_keep_fallback(partial): + inputs, expected = operands() + expr = blosc2.lazyexpr("x + (y - 1)", inputs) + item = slice(3, 250, 2) if partial else () + result = expr.compute(item, chunks=(64,), blocks=(16,), cparams={"clevel": 0}) + np.testing.assert_array_equal(result[:], expected[item] if partial else expected) + assert result.chunks == (64,) + assert not hasattr(expr, "_native_execution_report") + + +def test_native_prefilter_error_is_not_replayed(monkeypatch): + inputs, _ = operands() + expr = blosc2.lazyexpr("x + (y - 1)", inputs) + forbid_fallback(monkeypatch) + calls = [] + + def failing(*args, **kwargs): + calls.append(True) + raise RuntimeError("Injected native prefilter failure") + + monkeypatch.setattr(blosc2.NDArray, "_execute_portable_prefilter", failing) + with pytest.raises(RuntimeError, match="Injected native"): + expr.compute(cparams={"clevel": 0}) + assert len(calls) == 1 + + +def test_matching_grid_with_out_and_comparison_output(monkeypatch): + inputs, _ = operands() + expected = inputs["x"][:] > 0.5 + expr = blosc2.lazyexpr("x > 0.5", inputs) + output = blosc2.uninit(expected.shape, dtype="bool", chunks=(128,), blocks=(32,), cparams={"clevel": 0}) + forbid_fallback(monkeypatch) + assert expr.compute(out=output, chunks=(128,), blocks=(32,)) is output + np.testing.assert_array_equal(output[:], expected) + assert expr._native_execution_report["route"] == "portable-prefilter" + + +def test_input_output_alias_retains_fallback(): + inputs, expected = operands() + expr = blosc2.lazyexpr("x + (y - 1)", inputs) + result = expr.compute(out=inputs["x"]) + assert result is inputs["x"] + np.testing.assert_array_equal(result[:], expected) + assert not hasattr(expr, "_native_execution_report") + + +def test_nonfinite_named_literals_retain_fallback(): + inputs, _ = operands() + expr = (inputs["x"] + 1) == np.nan + result = expr.compute(cparams={"clevel": 0}) + np.testing.assert_array_equal(result[:], False) + assert not hasattr(expr, "_native_execution_report") diff --git a/tests/test_lazyexpr_resident.py b/tests/test_lazyexpr_resident.py new file mode 100644 index 000000000..4827063d6 --- /dev/null +++ b/tests/test_lazyexpr_resident.py @@ -0,0 +1,156 @@ +import gc + +import numpy as np +import pytest + +import blosc2 + + +@pytest.fixture(autouse=True) +def runtime(): + if not hasattr(blosc2.blosc2_ext.NativeGraphHandle, "resident_artifact"): + pytest.skip("Requires borrowed graph artifact binding") + previous = blosc2.nthreads + blosc2.set_nthreads(4) + yield + blosc2.set_nthreads(previous) + + +@pytest.fixture +def parallel_runtime(runtime): + from blosc2.graph_plan import NativeGraph + + if blosc2.IS_WASM: + pytest.skip("Parallel graph execution requires host threads") + plan = NativeGraph.from_expression("x + 1", {"x": np.dtype("float64")}, jit=True) + if not plan.has_jit: + pytest.skip("Parallel graph execution requires an available portable JIT backend") + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("expression", ["x + (y - 1)", "x > y", "x * 0.5 + y"]) +def test_native_graph_parallel(parallel_runtime, dtype, expression): + x = np.linspace(0, 1, 600_003, dtype=dtype) + y = np.linspace(1, 2, 600_003, dtype=dtype) + expr = blosc2.lazyexpr(expression, {"x": x, "y": y}) + expected = expr.compute(_require_native=True, jit=True, _native_tile_items=1023, _getitem=True) + with blosc2.jit_options(jit=True): + np.testing.assert_array_equal(expr[:], expected) + report = expr._native_execution_report + assert report["route"] == "parallel-resident" + assert report["backend"] == "portable-jit" + assert report["threads"] == 4 + assert report["input_materialization_bytes"] == 0 + assert report["normalization_bytes"] == 0 + + +@pytest.mark.parametrize( + "case", ["strided", "broadcast", "partial", "serial", "tile-override", "typed-capture"] +) +def test_original_graph_execution_retained(case): + x = np.linspace(0, 1, 600_003) + y = x[::-1] if case == "strided" else x[:1] if case == "broadcast" else x + expr = blosc2.lazyexpr( + "x + (y - c)", {"x": x, "y": y, "c": np.float64(1) if case == "typed-capture" else 1} + ) + kwargs = {"_require_native": True, "jit": True, "_getitem": True} + item = (slice(0, 400_000),) if case == "partial" else () + if case == "serial": + blosc2.set_nthreads(1) + if case == "tile-override": + kwargs["_native_tile_items"] = 64 + result = expr.compute(item=item, **kwargs) + np.testing.assert_array_equal(result, (x + (y - 1))[item]) + if case not in {"strided", "broadcast"}: + assert expr._native_execution_report.get("route") != "parallel-resident" + + +def test_reduction_and_staged_graph_retained(): + x = np.ones(600_003) + for expression, expected in (("sum(x)", float(x.size)), ("x + sum(x)", x + x.size)): + expr = blosc2.lazyexpr(expression, {"x": x}) + np.testing.assert_array_equal(expr.compute(_require_native=True, jit=True, _getitem=True), expected) + assert expr._native_execution_report.get("route") != "parallel-resident" + + +def test_threadless_runtime_keeps_native_graph_values(monkeypatch): + x = np.linspace(0, 1, 600_003) + expr = blosc2.lazyexpr("x + (x - 1)", {"x": x}) + monkeypatch.setattr(blosc2, "IS_WASM", True) + + def forbidden(*args, **kwargs): + pytest.fail("Threadless runtime scheduled graph workers") + + monkeypatch.setattr("blosc2.resident_execution.resident_pool", forbidden) + result = expr.compute(_require_native=True, jit=True, _getitem=True) + np.testing.assert_array_equal(result, x + (x - 1)) + assert expr._native_execution_report.get("route") != "parallel-resident" + + +def test_graph_fp_status_matches_original(parallel_runtime): + x = np.full(600_003, np.finfo(np.float64).max) + expr = blosc2.lazyexpr("x * x", {"x": x}) + expected = expr.compute(_require_native=True, jit=True, _native_tile_items=1023, _getitem=True) + status = expr._native_execution_report["fp_flags"] + np.testing.assert_array_equal(expr[:], expected) + assert expr._native_execution_report["fp_flags"] == status + + +def test_lazy_map_participation_mask_preserved(parallel_runtime): + x = np.linspace(-1, 1, 600_003) + y = np.ones_like(x) + # Avoid the existing where-construction path, which requires a Blosc2 condition. + expr = blosc2.lazyexpr("x + y", {"x": x, "y": y}) + names = tuple(expr.operands) + expr.expression = f"where({names[0]} > 0, sqrt({names[0]}), {names[1]})" + expected = expr.compute(_require_native=True, jit=True, _native_tile_items=1023, _getitem=True) + result = expr.compute(_require_native=True, jit=True, _getitem=True) + np.testing.assert_array_equal(result, expected) + assert expr._native_execution_report["route"] == "parallel-resident" + assert expr._native_execution_report["fp_flags"] == 0 + + +def test_graph_execution_failure_never_replays(parallel_runtime, monkeypatch): + def fail(*args, **kwargs): + raise ArithmeticError("Parallel graph failed") + + monkeypatch.setattr("blosc2.native_graph._parallel_resident_graph", fail) + monkeypatch.setattr("blosc2.native_graph.prepare_resident", lambda *args, **kwargs: None) + x = np.ones(600_003) + expr = blosc2.lazyexpr("x + 1", {"x": x}) + with pytest.raises(ArithmeticError, match="Parallel graph failed"): + expr[:] + + +def test_borrowed_artifact_retains_native_owner(parallel_runtime): + from blosc2.graph_plan import NativeGraph + + plan = NativeGraph.from_expression("x + 1", {"x": np.dtype("float64")}, jit=True) + borrowed = plan._handle.resident_artifact() + assert borrowed is not None + del plan + gc.collect() + values = np.arange(100.0) + result = borrowed.evaluate_block({"x": values}, values.shape) + np.testing.assert_array_equal(result, values + 1) + del borrowed + gc.collect() + + +def test_resident_kernel_retains_plan_without_reimport(runtime, monkeypatch): + from blosc2.native_graph import resident_map_kernel + + plan = blosc2.NativeGraph.from_expression("x + (y - 1)", {"x": "float64", "y": "float64"}) + + def forbidden(*args, **kwargs): + pytest.fail("Resident map reimported a validated graph artifact") + + monkeypatch.setattr(blosc2.PortableKernel, "from_json", forbidden) + kernel = resident_map_kernel(plan) + assert kernel.to_json() == plan.map_json() + resident_map_kernel.cache_clear() + del plan + gc.collect() + x = np.arange(17.0) + y = x + 1 + np.testing.assert_array_equal(kernel.evaluate_block({"x": x, "y": y}), x + (y - 1)) diff --git a/tests/test_locking.py b/tests/test_locking.py index 6f2757acc..19f0b79ca 100644 --- a/tests/test_locking.py +++ b/tests/test_locking.py @@ -446,6 +446,7 @@ def test_cross_process_multiwriter_update(tmp_path, iters): import numpy as np import blosc2 +blosc2.set_nthreads(1) urlpath, writer_id, chunk_nitems, iters = sys.argv[1], int(sys.argv[2]), int(sys.argv[3]), int(sys.argv[4]) schunk = blosc2.open(urlpath, mode="a", locking=True) nchunk = writer_id % schunk.nchunks @@ -507,6 +508,9 @@ def test_cross_process_open_race_under_update(tmp_path): schunk = create_schunk(urlpath, contiguous=True, locking=True) del schunk + # The race is between processes, not codec/numexpr workers. Avoid creating + # dozens of unrelated threads in each of the eight fresh interpreters. + env = {**os.environ, "NUMEXPR_MAX_THREADS": "1", "NUMEXPR_NUM_THREADS": "1"} writers = [ subprocess.Popen( [ @@ -517,12 +521,13 @@ def test_cross_process_open_race_under_update(tmp_path): str(wid), str(CHUNK_NITEMS), str(iters), - ] + ], + env=env, ) for wid in range(nwriters) ] openers = [ - subprocess.Popen([sys.executable, "-c", OPEN_RACE_OPENER_SCRIPT, str(urlpath), str(iters)]) + subprocess.Popen([sys.executable, "-c", OPEN_RACE_OPENER_SCRIPT, str(urlpath), str(iters)], env=env) for _ in range(nopeners) ] procs = writers + openers diff --git a/tests/test_menudet_arithmetic.py b/tests/test_menudet_arithmetic.py new file mode 100644 index 000000000..9953e863e --- /dev/null +++ b/tests/test_menudet_arithmetic.py @@ -0,0 +1,195 @@ +"""NumPy-profile arithmetic, scalar authoring and persistence regressions.""" + +import json +import os +from pathlib import Path + +import numpy as np +import pytest + +import blosc2 +from tools import menudet_conformance as compat + + +def export(source, inputs, output, **kwargs): + return blosc2.DSLKernel.from_source(source).export(inputs, output, version="1.0", **kwargs) + + +@pytest.fixture(autouse=True) +def numpy_runtime(): + try: + export("def k(x):\n return x\n", {"x": "int8"}, "int8") + except blosc2.PortableArtifactError as error: + if error.status != "unsupported_requirement": + raise + if os.environ.get("MENUDET_NUMPY_ARITHMETIC_CORPUS"): + pytest.fail("Explicit testing requires a rebuilt Menudet 1.0 native dependency") + pytest.skip("Installed native dependency does not implement Menudet 1.0") + + +def test_menudet_1_default_and_metadata_only_inference(): + source = "def k(x):\n return (x + 1) * 2\n" + author = blosc2.DSLKernel.from_source(source) + default = blosc2.PortableKernel.from_json(author.export({"x": "int8"}, "int64")) + new = blosc2.PortableKernel.from_json(export(source, {"x": "int8"}, "int64")) + assert default.schema_version == "1.0" + assert default.inferred_dtype == np.dtype("int8") + assert new.schema_version == "1.0" + assert new.inferred_dtype == np.dtype("int8") + x = np.array([127, -128], dtype="int8") + with np.errstate(over="ignore"): + np.testing.assert_array_equal(default.evaluate({"x": x}), ((x + 1) * 2).astype("int64")) + np.testing.assert_array_equal(new.evaluate({"x": x}), ((x + 1) * 2).astype("int64")) + assert new.to_json() == export(source, {"x": "int8"}, "int64") + # Semantic identity is explicit: partial upgrades and future profiles reject. + for schema, language in [("1.0", "1.1"), ("1.1", "1.0"), ("1.1", "1.1"), ("9.0", "9.0")]: + artifact = json.loads(new.to_json()) + artifact["schema_version"], artifact["language"]["version"] = schema, language + with pytest.raises(blosc2.PortableArtifactError): + blosc2.PortableKernel.from_json(json.dumps(artifact)) + + +@pytest.mark.parametrize( + ("value", "explicit", "expected_dtype"), + [ + (1, None, "float32"), + (np.int64(1), None, "float64"), + (1, "int64", "float64"), + (np.float64(1), None, "float64"), + ], +) +def test_weak_and_typed_constants(value, explicit, expected_dtype): + artifact = export( + "def k(x, c):\n return x + c\n", + {"x": "float32"}, + expected_dtype, + constants={"c": value}, + capture_dtypes={} if explicit is None else {"c": explicit}, + ) + encoded = json.loads(artifact)["constants"][0] + assert encoded["category"] == ("weak" if type(value) is int and explicit is None else "typed_scalar") + kernel = blosc2.PortableKernel.from_json(artifact) + assert kernel.inferred_dtype == np.dtype(expected_dtype) + x = np.array([1], dtype="float32") + np.testing.assert_array_equal(kernel.evaluate({"x": x}), x + (np.int64(value) if explicit else value)) + + +def test_weak_constant_range_and_same_handle_recovery(): + artifact = export("def k(x, c):\n return x + c\n", {"x": "int8"}, "int8", constants={"c": 128}) + kernel = blosc2.PortableKernel.from_json(artifact) + for _ in range(3): + with pytest.raises(blosc2.PortableArtifactError, match="evaluation_error"): + kernel.evaluate({"x": np.array([1], dtype="int8")}) + # A typed scalar participates in strong promotion before explicit narrowing. + typed = blosc2.PortableKernel.from_json( + export("def k(x, c):\n return x + c\n", {"x": "int8"}, "int8", constants={"c": np.int64(128)}) + ) + assert typed.inferred_dtype == np.dtype("int64") + assert typed.evaluate({"x": np.array([1], dtype="int8")})[0] == -127 + + +def test_float_cast_failure_then_success(): + kernel = blosc2.PortableKernel.from_json( + export("def k(x):\n return int8(x)\n", {"x": "float64"}, "int8") + ) + for values in [[np.nan], [np.inf], [128.0], [-129.0]]: + with pytest.raises(blosc2.PortableArtifactError, match="evaluation_error"): + kernel.evaluate({"x": np.array(values)}) + assert kernel.evaluate({"x": np.array([-1.9])})[0] == -1 + + +def test_construction_is_not_array_narrowing(): + # A weak scalar constructor is checked; conversion of array elements wraps. + literal = blosc2.PortableKernel.from_json( + export("def k(x):\n return x + int8(128)\n", {"x": "int8"}, "int8") + ) + with pytest.raises(blosc2.PortableArtifactError, match="evaluation_error"): + literal.evaluate({"x": np.array([1], dtype="int8")}) + array = blosc2.PortableKernel.from_json( + export("def k(x):\n return int8(x)\n", {"x": "int64"}, "int8") + ) + assert array.evaluate({"x": np.array([128], dtype="int64")})[0] == -128 + + +@pytest.mark.parametrize("shape", [(), (1,)]) +def test_typed_zero_dimensional_array(shape): + source = "def k(x, y):\n return x + y\n" + kernel = blosc2.PortableKernel.from_json(export(source, {"x": "float32", "y": "float64"}, "float64")) + assert kernel.inferred_dtype == np.dtype("float64") + actual = kernel.evaluate({"x": np.ones(shape, dtype="float32"), "y": np.ones(shape, dtype="float64")}) + assert actual.shape == shape + assert actual.dtype == np.dtype("float64") + + +def test_cast_policy_rejection_is_metadata_only(): + source = "def k(x):\n return x\n" + for policy in ["safe", "same_kind"]: + with pytest.raises(blosc2.PortableArtifactError, match="cast policy"): + export(source, {"x": "float64"}, "int8", casting=policy) + assert blosc2.PortableKernel.from_json( + export(source, {"x": "int8"}, "int64", casting="safe") + ).inferred_dtype == np.dtype("int8") + + +def test_authoring_captured_scalar(): + c = 1 + + @blosc2.dsl_kernel + def k(x): + return x + c + + artifact = k.export({"x": "float32"}, "float32", version="1.0") + assert json.loads(artifact)["constants"][0]["category"] == "weak" + kernel = blosc2.PortableKernel.from_json(artifact) + assert kernel.inferred_dtype == np.dtype("float32") + assert kernel.evaluate({"x": np.array([1], dtype="float32")})[0] == 2 + + +def test_local_weak_scalar_and_float_literal_overflow(): + source = "def k(x):\n c = 1 + 2\n return x + c\n" + kernel = blosc2.PortableKernel.from_json(export(source, {"x": "float32"}, "float32")) + assert kernel.inferred_dtype == np.dtype("float32") + assert kernel.evaluate({"x": np.array([1], dtype="float32")})[0] == 4 + kernel = blosc2.PortableKernel.from_json( + export("def k(x):\n return x + 1e100\n", {"x": "float32"}, "float32") + ) + assert np.isposinf(kernel.evaluate({"x": np.array([1], dtype="float32")})[0]) + + +def test_persistence_preserves_profile(tmp_path): + x = blosc2.asarray(np.array([127, -128, 0, 1], dtype="int8"), urlpath=str(tmp_path / "x.b2nd")) + kernel = blosc2.PortableKernel.from_json(export("def k(x):\n return x + 1\n", {"x": "int8"}, "int8")) + lazy = kernel.lazy({"x": x}, partitions=(2,)) + path = str(tmp_path / "recipe.b2nd") + lazy.save(path) + restored = blosc2.open(path) + assert restored.kernel.schema_version == "1.0" + assert restored.kernel.inferred_dtype == np.dtype("int8") + assert restored.kernel.to_json() == kernel.to_json() + np.testing.assert_array_equal(restored[:], np.array([-128, -127, 1, 2], dtype="int8")) + + +def test_shared_arithmetic_matrix(tmp_path): + corpus = os.environ.get("MENUDET_NUMPY_ARITHMETIC_CORPUS") + runner = os.environ.get("MENUDET_NUMPY_RUNNER") + if not corpus or not runner: + pytest.skip("Select authoritative arithmetic corpus and native runner explicitly") + report = compat.paired(json.loads(Path(corpus).read_text()), Path(runner), tmp_path) + compat.check(report) + assert all(row["outcome"] == "matching" for row in report["requests"]["off"]["native"]) + if os.environ.get("MENUDET_REQUIRE_JIT"): + assert report["eligible_jit_cases"] > 0 + assert not any(row["jit_eligible"] for row in report["requests"]["off"]["native"]) + + +@pytest.mark.parametrize("seed", [1729, 20261009]) +def test_full_width_seeded_arithmetic(seed, tmp_path): + from tools.menudet_arithmetic import property_cases + + corpus = os.environ.get("MENUDET_NUMPY_ARITHMETIC_CORPUS") + runner = os.environ.get("MENUDET_NUMPY_RUNNER") + if not corpus or not runner: + pytest.skip("Select authoritative arithmetic corpus and native runner explicitly") + vectors = json.loads(Path(corpus).read_text()) + vectors["cases"] = property_cases(seed) + compat.check(compat.paired(vectors, Path(runner), tmp_path)) diff --git a/tests/test_menudet_arrays.py b/tests/test_menudet_arrays.py new file mode 100644 index 000000000..d7f767468 --- /dev/null +++ b/tests/test_menudet_arrays.py @@ -0,0 +1,171 @@ +"""Native logical traversal; no NumPy numerical evaluation inside the runtime.""" + +import os + +import numpy as np +import pytest + +import blosc2 +from conftest import orthogonal_cases + +DTYPES = [ + "bool", + "int8", + "int16", + "int32", + "int64", + "uint8", + "uint16", + "uint32", + "uint64", + "float32", + "float64", +] + + +def kernel(expression="x", inputs=None, output="float64"): + inputs = inputs or {"x": output} + author = blosc2.DSLKernel.from_source(f"def k({', '.join(inputs)}):\n return {expression}\n") + return blosc2.PortableKernel.from_json(author.export(inputs, output, version="1.0", casting="unsafe")) + + +@pytest.fixture(autouse=True) +def runtime(): + try: + kernel().evaluate_array({"x": np.ones(1)}) + except blosc2.PortableArtifactError as error: + if os.environ.get("MENUDET_REQUIRE_ARRAY_RUNTIME"): + pytest.fail(str(error)) + pytest.skip("Installed dependency does not implement native logical traversal") + + +@pytest.mark.parametrize( + ("layout", "dtype"), + orthogonal_cases(["C", "F", "reverse", "step", "endian", "unaligned"], DTYPES), +) +def test_broadcast_and_layout(layout, dtype): + x = np.arange(24).reshape(4, 6).astype(dtype) + if layout == "F": + x = np.asfortranarray(x) + elif layout == "reverse": + x = x[::-1, ::-1] + elif layout == "step": + x = x[:, ::2] + elif layout == "endian": + x = x.astype(x.dtype.newbyteorder(">" if np.little_endian else "<")) + elif layout == "unaligned": + base = np.empty(x.nbytes + 1, dtype="uint8") + v = np.ndarray(x.shape, dtype=x.dtype, buffer=base, offset=1) + v[:] = x + x = v + k = kernel("x + y" if dtype != "bool" else "x | y", {"x": dtype, "y": dtype}, dtype) + y = np.ones((1, x.shape[1]), dtype=dtype) + values, report = k.evaluate_array({"x": x, "y": y}, tile_items=5, return_report=True) + np.testing.assert_array_equal(values, x + y if dtype != "bool" else x | y) + assert values.dtype == np.dtype(dtype) + assert values.flags.owndata + assert values.flags.c_contiguous + assert report["temporary_bytes"] <= 5 * 2 * np.dtype(dtype).itemsize + + +@pytest.mark.parametrize( + ("dtype", "op", "axis"), + orthogonal_cases(DTYPES, ["sum", "prod", "min", "max", "any", "all"], [None, (), 0, -1, (0, 2)]), +) +def test_logical_reductions(dtype, op, axis): + x = (np.arange(24).reshape(2, 3, 4) % 3).astype(dtype) + k = kernel(output=dtype) + # Menudet's portable accumulator widths are fixed, unlike NumPy's native + # integer defaults (32 bits on WASM). Specify the contract in the oracle. + options = {} + if op in ("sum", "prod") and x.dtype.kind in "biu": + options["dtype"] = "uint64" if x.dtype.kind == "u" else "int64" + reference = getattr(np, op)(x, axis=axis, keepdims=True, **options) + previous = None + for tile in (1, 5, 32): + result = k.evaluate_array({"x": x}, reduction=op, axis=axis, keepdims=True, tile_items=tile) + assert result.dtype == reference.dtype + np.testing.assert_array_equal(result, reference) + if previous is not None: + assert result.tobytes() == previous.tobytes() + previous = result + + +@pytest.mark.parametrize("op", ["sum", "prod", "min", "max", "any", "all"]) +def test_masks_empty_and_initial(op): + x = np.arange(12).reshape(3, 4).astype("float64") + mask = np.array([[True, False, True, False]]) + k = kernel() + options = {"initial": 2} if op in {"sum", "prod", "min", "max"} else {} + result = k.evaluate_array({"x": x}, reduction=op, axis=1, where=mask, **options) + np.testing.assert_array_equal(result, getattr(np, op)(x, axis=1, where=mask, **options)) + empty = np.empty((2, 0)) + if op in {"min", "max"}: + with pytest.raises(blosc2.PortableArtifactError, match="initial"): + k.evaluate_array({"x": empty}, reduction=op, axis=1) + else: + np.testing.assert_array_equal( + k.evaluate_array({"x": empty}, reduction=op, axis=1), getattr(np, op)(empty, axis=1) + ) + + +def test_zero_copy_and_bounds_rejection(): + x = np.arange(100, dtype="float64") + result, report = kernel().evaluate_array({"x": x}, tile_items=9, return_report=True) + assert report["gathered_bytes"] == report["temporary_bytes"] == 0 + assert report["zero_copy_tiles"] == 12 + np.testing.assert_array_equal(result, x) + bad = np.lib.stride_tricks.as_strided(x, shape=(200,), strides=(8,)) + with pytest.raises(blosc2.PortableArtifactError, match="bounds"): + kernel().evaluate_array({"x": bad}) + with pytest.raises(blosc2.PortableArtifactError, match="axes"): + kernel().evaluate_array({"x": x}, reduction="sum", axis=(0, 0)) + + +def test_empty_broadcast_and_zero_dimensional(): + k = kernel("x + y", {"x": "float64", "y": "float64"}) + assert k.evaluate_array({"x": np.empty((0, 3)), "y": np.ones((1, 3))}).shape == (0, 3) + assert k.evaluate_array({"x": np.array(1.0), "y": np.array(2.0)}).shape == () + assert k.evaluate_array({"x": np.array(1.0), "y": np.array(2.0)}) == 3 + + +def test_wraparound_and_order_across_storage_chunks(): + x = np.array([2**63 - 1, 1, 2**63 - 1, 1], dtype="int64") + k = kernel(output="int64") + for chunks in ((2,), (4,)): + stored = blosc2.asarray(x, chunks=chunks, blocks=(1,)) + result = k.evaluate_array({"x": stored[:]}, reduction="sum", tile_items=3) + np.testing.assert_array_equal(result, np.sum(x)) + f = np.array([1e16, 1, -1e16, 1.0]) + outputs = [kernel().evaluate_array({"x": f}, reduction="sum", tile_items=tile) for tile in (1, 2, 3, 10)] + assert all(value == 1 for value in outputs) + + +def test_normalization_allocations_and_masked_status(): + source = bytes(np.arange(6, dtype="float64").tobytes()) + x = np.frombuffer(source, dtype="float64") + result, report = kernel().evaluate_array({"x": x}, return_report=True) + np.testing.assert_array_equal(result, x) + assert report["normalization_bytes"] == 0 # Read-only buffer owners now expose checked native bounds. + k = kernel("sqrt(x)") + result, report = k.evaluate_array( + {"x": np.array([-1.0, 4.0])}, reduction="sum", where=np.array([False, True]), return_report=True + ) + assert result == 2 + assert report["fp_flags"] == 0 + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +def test_sum_forward_error_policy(dtype): + import math + + rng = np.random.Generator(np.random.PCG64(20261009)) + x = rng.normal(size=1001).astype(dtype) + expected = math.fsum(float(v) for v in x) + epsilon = np.finfo(dtype).eps / 2 + bound = ((x.size * epsilon) / (1 - x.size * epsilon)) * math.fsum(abs(float(v)) for v in x) + outputs = [ + kernel(output=dtype).evaluate_array({"x": x}, reduction="sum", tile_items=n) for n in (1, 17, 1024) + ] + assert all(abs(float(value) - expected) <= bound for value in outputs) + assert len({value.tobytes() for value in outputs}) == 1 diff --git a/tests/test_menudet_conformance.py b/tests/test_menudet_conformance.py new file mode 100644 index 000000000..77e10083e --- /dev/null +++ b/tests/test_menudet_conformance.py @@ -0,0 +1,199 @@ +"""M2 comparator, layout, minimizer and shared native corpus regressions.""" + +import copy +import json +import os +import subprocess +from pathlib import Path +from types import SimpleNamespace + +import numpy as np +import pytest + +from tools import menudet_conformance as compat + + +@pytest.fixture +def native_inputs(): + corpus = os.environ.get("MENUDET_NUMPY_CORPUS_V2") + runner = os.environ.get("MENUDET_NUMPY_RUNNER") + if not corpus or not runner: + pytest.skip("Select authoritative v2 corpus and native runner explicitly") + return json.loads(Path(corpus).read_text()), Path(runner) + + +@pytest.mark.parametrize("kind", ["bitwise", "exact", "ulp", "tolerance"]) +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +def test_comparison_policies(kind, dtype): + expected = np.array([1], dtype=dtype) + adjacent = np.nextafter(expected, np.array([2], dtype=dtype)) + policy = {**compat.BITWISE, "kind": kind, "max_ulp": 1} + errors = compat.compare(compat.describe(adjacent), compat.describe(expected), policy) + assert bool(errors) == (kind in {"bitwise", "exact"}) + policy = {**compat.BITWISE, "kind": "tolerance", "atol": 1e-3} + assert not compat.compare( + compat.describe(expected + np.array([1e-4], dtype=dtype)), compat.describe(expected), policy + ) + assert compat.compare(compat.describe(expected + 0.1), compat.describe(expected), policy) + + +def test_nan_payload_and_signed_zero_policies(): + positive = compat.describe(np.array([0.0])) + negative = compat.describe(np.array([-0.0])) + assert compat.compare(positive, negative, compat.BITWISE) + assert not compat.compare(positive, negative, {**compat.BITWISE, "signed_zero": "ignore"}) + first = {"dtype": "float64", "shape": [1], "encoding": "raw-be-hex", "hex": "7ff8000000000001"} + second = {**first, "hex": "7ff8000000000002"} + assert compat.compare(first, second, compat.BITWISE) + assert not compat.compare(first, second, {**compat.BITWISE, "nan": "equal"}) + assert compat.compare( + compat.describe(np.array([np.inf])), compat.describe(np.array([-np.inf])), compat.BITWISE + ) + + +@pytest.mark.parametrize("order", ["C", "F"]) +@pytest.mark.parametrize("byteorder", ["native", "little", "big"]) +def test_layout_recipes(order, byteorder): + array = np.arange(12, dtype="int64").reshape(3, 4) + item = compat.describe( + array, "x", {"order": order, "byteorder": byteorder, "step": 2, "reverse_axis": 0} + ) + actual = compat.decode(item) + np.testing.assert_array_equal(actual, array) + assert actual.strides[0] < 0 + assert not actual.flags.c_contiguous + + +@pytest.mark.parametrize( + ("machine", "key"), + [("AMD64", "x86_64"), ("x86_64", "x86_64"), ("aarch64", "arm64"), ("arm64", "arm64")], +) +def test_platform_qualified_reference_is_exact(machine, key, monkeypatch): + arm = compat.describe(np.array([2**63 - 1], dtype="int64")) + x64 = compat.describe(np.array([-(2**63)], dtype="int64")) + case = { + "expected": arm, + "platform_qualification": "Host-specific nonfinite cast sentinel", + "reference_expected_by_machine": {"arm64": arm, "x86_64": x64}, + "baseline": {"status": -5, "category": "evaluation_error"}, + } + monkeypatch.setattr(compat.platform, "machine", lambda: machine) + expected = compat.reference_expected(case) + assert expected == case["reference_expected_by_machine"][key] + assert compat.compare(x64 if key == "arm64" else arm, expected, compat.BITWISE) + assert case["baseline"] == {"status": -5, "category": "evaluation_error"} + monkeypatch.setattr(compat.platform, "machine", lambda: "unlisted") + assert compat.reference_expected(case) == arm + del case["platform_qualification"] + with pytest.raises(ValueError, match="platform qualification"): + compat.reference_expected(case) + + +def test_native_input_is_closed_before_subprocess(monkeypatch, tmp_path): + case = compat.make_case("closed-input", "identity", "x", [np.array([1.0])]) + corpus = {"schema_version": compat.VERSION, "cases": [case]} + row = {"id": case["id"], "outcome": "matching"} + paths = [] + + def run(command, **kwargs): + path = Path(command[1]) + assert json.loads(path.read_text()) == corpus + # Windows permits this only after the writer closes its handle. + path.unlink() + paths.append(path) + return SimpleNamespace(returncode=0, stdout=json.dumps(row), stderr="") + + monkeypatch.setattr(compat.subprocess, "run", run) + assert compat.native(corpus, tmp_path / "runner", tmp_path) == [row] + assert not paths[0].parent.exists() + + +def test_seeded_generator_and_minimization(): + assert compat.property_cases(1729) == compat.property_cases(1729) + failure = compat.property_cases(1729)[-1] + + def fails(case): + # Reference predicate for testing the generic minimizer, not a second + # execution backend or an arithmetic contract used by production code. + arrays = [compat.checkpoint.decode(item).astype("int64") for item in case["inputs"]] + return bool(np.any(arrays[0] + arrays[1] > 127)) + + reduced = compat.minimized_failure(failure, fails) + assert [item["hex"] for item in reduced["inputs"]] == ["7f", "01"] + with pytest.raises(ValueError, match="passing case"): + compat.minimized_failure(compat.property_cases(1729)[0], fails) + + +def test_paired_corpus(native_inputs, tmp_path, monkeypatch): + import numexpr + + corpus, runner = native_inputs + + def forbidden(*args, **kwargs): + raise AssertionError("No NumExpr fallback in portable conformance") + + monkeypatch.setattr(numexpr, "evaluate", forbidden) + report = compat.paired(corpus, runner, tmp_path) + compat.check(report) + assert not any(row.get("jit_eligible") for row in report["requests"]["off"]["native"]) + if os.environ.get("MENUDET_REQUIRE_JIT") == "1": + assert report["eligible_jit_cases"] > 0 + assert report["reference_drift"] == [] + for mode in ("off", "on"): + rows = report["requests"][mode]["native"] + assert len(rows) == len(corpus["cases"]) + assert sum(row["outcome"] == "skipped" for row in rows) == 2 + assert all(row.get("environment_restored", True) for row in rows) + assert all(row.get("recovery_ok", True) for row in rows) + + +@pytest.mark.parametrize("kind", ["bitwise", "exact", "ulp", "tolerance"]) +def test_native_python_comparator_parity(native_inputs, tmp_path, kind): + corpus, runner = native_inputs + actual = np.array([1.0]) + expected = np.nextafter(actual, np.array([2.0])) + case = compat.make_case( + "comparator-oracle", "identity", "x", [actual], policy={**compat.BITWISE, "kind": kind, "max_ulp": 1} + ) + case["expected"] = compat.describe(expected) + test = {**corpus, "cases": [case]} + row = compat.native(test, runner, tmp_path, observe=True)[0] + assert row["reference_match"] == ( + not compat.compare(compat.describe(actual), case["expected"], case["comparison"]) + ) + + +@pytest.mark.parametrize( + "corruption", ["nan-policy", "negative-tolerance", "encoding", "layout", "extent", "baseline"] +) +def test_native_rejects_or_reports_corruption(native_inputs, tmp_path, corruption): + corpus, runner = native_inputs + case = copy.deepcopy(next(case for case in corpus["cases"] if case["id"] == "float32-weak-literal")) + corpus = {**corpus, "cases": [case]} + if corruption == "nan-policy": + case["comparison"]["nan"] = "future" + elif corruption == "negative-tolerance": + case["comparison"]["atol"] = -1 + elif corruption == "encoding": + case["inputs"][0]["hex"] = "zz" + elif corruption == "layout": + case["inputs"][0]["layout"]["reverse_axis"] = 8 + elif corruption == "extent": + case["inputs"][0]["shape"] = [2**63] + else: + case["baseline"]["output"]["hex"] = "3f8000003f800000" + path = tmp_path / "corrupt.json" + path.write_text(json.dumps(corpus)) + proc = subprocess.run([str(runner), str(path), "off"], capture_output=True, text=True, check=False) + assert proc.returncode == 1 + if corruption == "baseline": + assert json.loads(proc.stdout)["outcome"] == "regression" + + +def test_seeded_native_properties(native_inputs, tmp_path): + corpus, runner = native_inputs + report = compat.properties(corpus, runner, tmp_path, [1729]) + assert report["results"][0]["matching"] == 49 + assert report["results"][0]["known_divergences"] == 0 + assert report["results"][0]["minimized"] is None + assert report["results"][0]["promoted_case_id"] == "seed-1729-minimized-int8-overflow" diff --git a/tests/test_menudet_decorator.py b/tests/test_menudet_decorator.py new file mode 100644 index 000000000..c4180c3e9 --- /dev/null +++ b/tests/test_menudet_decorator.py @@ -0,0 +1,402 @@ +from __future__ import annotations + +import numpy as np +import pytest + +import blosc2 + + +@blosc2.menudet +def inferred(x, y): + return x + (y - 1) + + +@blosc2.menudet +def annotated(x: np.float64, y: np.float64) -> np.float64: + return x + (y - 1) + + +@pytest.mark.parametrize("dtype", ["int8", "int32", "uint64", "float32", "float64"]) +@pytest.mark.parametrize("compressed", [False, True]) +def test_inferred_arrays(dtype, compressed, native_graph_runtime): + x = np.arange(12).reshape(3, 4).astype(dtype) + y = np.ones((1, 4), dtype=dtype) + values = {"x": blosc2.asarray(x) if compressed else x, "y": y} + lazy = inferred(**values) + assert lazy.dtype == np.dtype(dtype) + np.testing.assert_array_equal(lazy[:], x + (y - 1)) + np.testing.assert_array_equal(lazy.compute()[:], x + (y - 1)) + + +def test_annotations_and_no_cast(native_graph_runtime): + x, y = np.arange(4.0), np.ones(4) + np.testing.assert_array_equal(annotated(x, y)[:], x + y - 1) + with pytest.raises(TypeError, match="expected dtype float64"): + annotated(x.astype("float32"), y) + + +def test_specialization_cache_and_mutation(native_graph_runtime): + x, y = np.arange(4.0), np.ones(4) + kernel = inferred.specialize(x, y) + assert kernel is inferred.specialize(y=y, x=x.reshape(2, 2)) + assert kernel is not inferred.specialize(x.astype("float32"), y.astype("float32")) + lazy = inferred(x, y) + x[:] = 10 + np.testing.assert_array_equal(lazy[:], np.full(4, 10.0)) + assert isinstance(kernel, blosc2.PortableKernel) + + +@pytest.mark.parametrize( + ("dtype", "jit", "annotate", "imports"), + [ + ("float64", None, False, 1), + ("float64", True, False, 1), + ("float64", False, False, 1), + ("int32", False, False, 1), + ("float64", None, True, 1), + ("float64", True, True, 1), + ], +) +def test_specialization_reuses_validated_export( + native_graph_runtime, monkeypatch, dtype, jit, annotate, imports +): + import blosc2.portable_kernel as portable + + offset = 2 + + def function(x): + return x + offset + + if annotate: + function.__annotations__["return"] = np.float64 + author = blosc2.menudet(jit=jit)(function) + original_captures = portable._export_captures + original_import = blosc2.PortableKernel.from_json + captures, policies = [], [] + + def record_captures(*args, **kwargs): + captures.append(None) + return original_captures(*args, **kwargs) + + def record_import(cls, artifact, *, jit=None, infer_output=False): + policies.append(jit) + return original_import(artifact, jit=jit, infer_output=infer_output) + + monkeypatch.setattr(portable, "_export_captures", record_captures) + monkeypatch.setattr(blosc2.PortableKernel, "from_json", classmethod(record_import)) + x = np.arange(4, dtype=dtype) + kernel = author.specialize(x) + np.testing.assert_array_equal(kernel.evaluate_block({"x": x}), x + offset) + assert kernel.output_dtype == x.dtype + assert len(captures) == 1 + assert len(policies) == imports + assert policies[-1] is jit + assert kernel is author.specialize(x) + assert len(policies) == imports + + +def test_interpretation_and_python_never_called(native_graph_runtime, monkeypatch): + @blosc2.menudet(jit=False) + def k(x: np.float64) -> np.float64: + return x * 2 + + def forbidden(*args, **kwargs): + pytest.fail("Original Python function executed") + + monkeypatch.setattr(blosc2.DSLKernel, "__call__", forbidden) + monkeypatch.setattr(k._author, "func", forbidden) + x = np.arange(4.0) + np.testing.assert_array_equal(k(x)[:], x * 2) + assert not k.specialize(x).has_jit + + +def test_default_expression_interpretation(native_graph_runtime): + @blosc2.menudet + def k(x): + return x + 1 + + assert k._jit is None + x = np.arange(4.0) + assert k.specialize(x).execution_kind == "expression" + assert not k.specialize(x).has_jit + np.testing.assert_array_equal(k(x)[:], x + 1) + + +def test_automatic_program_and_explicit_overrides(native_graph_runtime, monkeypatch): + monkeypatch.delenv("ME_DSL_JIT", raising=False) + + @blosc2.menudet + def program(x): + y = x * 2 + return y + 1 + + @blosc2.menudet + def expression(x): + return x * 2 + 1 + + x = np.arange(7.0) + automatic = program.specialize(x) + assert automatic.execution_kind == "program" + forced = blosc2.PortableKernel.from_json(automatic.to_json(), jit=True) + assert automatic.has_jit == forced.has_jit + for author in (program, expression): + with blosc2.jit_options(jit=False): + interpreted = author.specialize(x) + assert not interpreted.has_jit + with blosc2.jit_options(jit=True): + compiled = author.specialize(x) + assert compiled is not interpreted + assert compiled.has_jit == blosc2.PortableKernel.from_json(compiled.to_json(), jit=True).has_jit + np.testing.assert_array_equal(author(x)[:], x * 2 + 1) + + +@pytest.mark.parametrize("environment", ["ME_DSL_JIT", "BLOSC_ME_JIT"]) +def test_automatic_specialization_environment_override(native_graph_runtime, monkeypatch, environment): + @blosc2.menudet + def expression(x): + return x + 1 + + monkeypatch.delenv("ME_DSL_JIT", raising=False) + monkeypatch.delenv("BLOSC_ME_JIT", raising=False) + x = np.arange(7.0) + interpreted = expression.specialize(x) + assert not interpreted.has_jit + monkeypatch.setenv(environment, "1") + compiled = expression.specialize(x) + assert compiled is not interpreted + assert compiled.has_jit == blosc2.PortableKernel.from_json(compiled.to_json(), jit=True).has_jit + + +@pytest.mark.parametrize("compiler", ["tcc", "cc"]) +def test_source_compiler_pragma_overrides_automatic_classification(native_graph_runtime, compiler): + import json + + x = np.arange(7.0) + artifact = json.loads(inferred.specialize(x, x).to_json()) + artifact["source"] = f"# me:compiler={compiler}\n" + artifact["source"] + automatic = blosc2.PortableKernel.from_json(json.dumps(artifact)) + forced = blosc2.PortableKernel.from_json(json.dumps(artifact), jit=True) + assert automatic.execution_kind == "expression" + assert automatic.has_jit == forced.has_jit + assert not blosc2.PortableKernel.from_json(json.dumps(artifact), jit=False).has_jit + + +def test_libm_kernel_roundtrip(native_graph_runtime): + # Numerical/operator matrices live in miniexpr. Check decorator binding, + # lazy reads and native artifact reconstruction with the resolved callbacks. + @blosc2.menudet + def trig(x): + return np.sin(x) + np.cos(x) + 1 + + x = np.linspace(-np.pi, np.pi, 257) + expected = np.sin(x) + np.cos(x) + 1 + np.testing.assert_allclose(trig(x)[:], expected, rtol=1e-14, atol=1e-14) + kernel = blosc2.PortableKernel.from_json(trig.specialize(x).to_json()) + np.testing.assert_allclose(kernel.evaluate({"x": x}), expected, rtol=1e-14, atol=1e-14) + + +def test_binding_defaults_and_scalars(native_graph_runtime): + @blosc2.menudet(jit=False) + def k(x, y: np.float64 = 2.0): + return x + y + + x = np.arange(4.0) + np.testing.assert_array_equal(k(x)[:], x + 2) + np.testing.assert_array_equal(k(y=3.0, x=x)[:], x + 3) + with pytest.raises(TypeError, match="missing"): + k() + with pytest.raises(TypeError, match="unannotated inputs"): + inferred(1, 2) + + +def test_capture_snapshot(native_graph_runtime, monkeypatch): + import blosc2.portable_kernel as portable + + scale = 2 + + @blosc2.menudet(jit=False) + def k(x): + return x * scale + + def forbidden(*args, **kwargs): + pytest.fail("Specialization repeated fixed-source capture analysis") + + monkeypatch.setattr(portable, "capture_analysis", forbidden) + scale = 7 + for dtype in ("float32", "float64"): + x = np.arange(4).astype(dtype) + np.testing.assert_array_equal(k(x)[:], x * 2) + + +def test_inferred_statement_return(native_graph_runtime): + @blosc2.menudet(jit=False) + def k(x): + y = x * 2 + return y + 1 + + x = np.arange(4, dtype="int32") + assert k(x).dtype == np.dtype("int32") + np.testing.assert_array_equal(k(x)[:], x * 2 + 1) + + +def test_block_reduction_contract(native_graph_runtime): + @blosc2.menudet(jit=False, cardinality="block_scalar", partitions=(2,)) + def k(x: np.int32) -> np.int64: + return block_sum(x) # noqa: F821 -- native Menudet builtin + + np.testing.assert_array_equal(k(np.arange(4, dtype="int32"))[:], [1, 5]) + + +def test_required_jit_unavailable(native_graph_runtime, monkeypatch): + @blosc2.menudet(require_jit=True) + def k(x: np.float64) -> np.float64: + return x + 1 + + monkeypatch.setattr(blosc2.PortableKernel, "has_jit", property(lambda self: False)) + with pytest.raises(RuntimeError, match="Required Menudet JIT"): + k(np.arange(4.0)) + + +def test_invalid_decorator_options(): + with pytest.raises(ValueError, match="conflicts"): + blosc2.menudet(jit=False, require_jit=True)(inferred.__wrapped__) + with pytest.raises(TypeError, match="must be bool"): + blosc2.menudet(jit="tcc")(inferred.__wrapped__) + with pytest.raises(TypeError, match="ordinary Python function"): + blosc2.menudet(np.add) + + +def test_unsupported_annotations(): + with pytest.raises(TypeError, match="dtype annotation"): + + @blosc2.menudet + def bad(x: list) -> np.float64: + return x + + +@pytest.mark.parametrize("route", ["resident", "block"]) +def test_native_execution_error_not_replayed(native_graph_runtime, monkeypatch, route): + lazy = inferred(np.arange(4.0), np.ones(4)) + + def failed(*args, **kwargs): + raise blosc2.PortableArtifactError("Invocation failed", status="evaluation_error") + + if route == "resident": + monkeypatch.setattr("blosc2.native_graph.execute_resident", failed) + else: + monkeypatch.delattr(lazy.kernel, "_resident_plan") + monkeypatch.setattr(blosc2.PortableKernel, "evaluate_block", failed) + with pytest.raises(blosc2.PortableArtifactError, match="Invocation failed"): + lazy[:] + + +def test_arithmetic_specialization_borrows_native_inference(native_graph_runtime, monkeypatch): + author = blosc2.menudet(inferred.__wrapped__) + x = np.arange(1000, dtype="int64") + y = x + 1 + + def forbidden(*args, **kwargs): + pytest.fail("Arithmetic specialization re-imported a portable artifact") + + with monkeypatch.context() as patch: + patch.setattr(blosc2.PortableKernel, "from_json", forbidden) + kernel = author.specialize(x, y) + assert kernel.output_dtype == x.dtype + assert kernel.inferred_dtype == x.dtype + assert kernel is author.specialize(x, y) + np.testing.assert_array_equal(kernel.lazy({"x": x, "y": y})[:], x + (y - 1)) + restored = blosc2.PortableKernel.from_json(kernel.to_json()) + np.testing.assert_array_equal(restored.evaluate({"x": x, "y": y}), x + (y - 1)) + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Parallel resident execution requires host threads") +def test_arithmetic_resident_rebinds_and_reuses_schedule(native_graph_runtime, monkeypatch): + author = blosc2.menudet(inferred.__wrapped__) + x = np.arange(1_000_000, dtype="int64") + y = x + 1 + lazy = author(x, y) + monkeypatch.setattr(blosc2, "nthreads", 2) + first = lazy[:] + schedule = lazy._resident_native[2] + lazy.inputs["x"] = x + 10 + monkeypatch.setattr(blosc2, "nthreads", 4) + second = lazy[:] + assert lazy._resident_native[2] is schedule + assert lazy._source_execution_report["threads"] == 4 + assert not np.shares_memory(first, second) + np.testing.assert_array_equal(first, x + (y - 1)) + np.testing.assert_array_equal(second, x + 10 + (y - 1)) + + +def test_arithmetic_threadless_large_read(native_graph_runtime, monkeypatch): + x = np.arange(300_003, dtype="int64") + author = blosc2.menudet(inferred.__wrapped__) + monkeypatch.setattr(blosc2, "IS_WASM", True) + + def forbidden(*args, **kwargs): + pytest.fail("Threadless arithmetic scheduled host workers") + + monkeypatch.setattr("blosc2.resident_execution.resident_pool", forbidden) + np.testing.assert_array_equal(author(x, x)[:], x + (x - 1)) + + +@pytest.mark.parametrize("options", [{"cflags": "-O1"}, {"jit": True, "cache_dir": "cache"}]) +def test_arithmetic_retains_explicit_compiler_options(native_graph_runtime, monkeypatch, tmp_path, options): + author = blosc2.menudet(inferred.__wrapped__) + x = np.arange(17, dtype="int64") + + def forbidden(*args, **kwargs): + pytest.fail("Arithmetic graph preparation bypassed explicit compiler options") + + monkeypatch.setattr(blosc2.NativeGraph, "from_expression", forbidden) + options = {**options, "cache_dir": tmp_path} + with blosc2.jit_options(**options): + np.testing.assert_array_equal(author(x, x)[:], x + (x - 1)) + + +def test_unavailable_return_inference(native_graph_runtime, monkeypatch): + @blosc2.menudet(jit=False) + def k(x): + return x + 1 + + monkeypatch.setattr(blosc2.PortableKernel, "inferred_dtype", property(lambda self: None)) + with pytest.raises(TypeError, match="return dtype annotation"): + k(np.arange(4.0)) + + +def test_full_read_fast_path_preserves_block_reduction(native_graph_runtime, monkeypatch): + @blosc2.menudet(jit=False) + def k(x: np.int32) -> np.int64: + return x - block_sum(x) # noqa: F821 -- native Menudet builtin + + x = np.arange(4, dtype="int32") + lazy = k(x) + + def forbidden(*args, **kwargs): + pytest.fail("Full single-group read built a selection-index array") + + monkeypatch.setattr(np, "arange", forbidden) + np.testing.assert_array_equal(lazy[:], [-6, -5, -4, -3]) + + +def test_full_read_fast_path_preserves_coordinates(native_graph_runtime): + @blosc2.menudet(jit=False, ndim=1) + def k(x: np.float64) -> np.float64: + return x + _i0 + _n0 # noqa: F821 -- native coordinate context + + np.testing.assert_array_equal(k(np.ones(4))[:], [5, 6, 7, 8]) + + +def test_decorated_artifact_is_standalone(native_graph_runtime): + x, y = np.arange(4.0), np.ones(4) + artifact = annotated.specialize(x, y).to_json() + kernel = blosc2.PortableKernel.from_json(artifact, jit=False) + np.testing.assert_array_equal(kernel.evaluate_array({"x": x, "y": y}), x + (y - 1)) + + +def test_none_is_not_a_dtype_annotation(): + with pytest.raises(TypeError, match="dtype annotation: None"): + + @blosc2.menudet + def bad(x) -> None: + return x diff --git a/tests/test_menudet_dispatch.py b/tests/test_menudet_dispatch.py new file mode 100644 index 000000000..92f9010a5 --- /dev/null +++ b/tests/test_menudet_dispatch.py @@ -0,0 +1,273 @@ +import numpy as np +import pytest + +import blosc2 +from blosc2.storage_readers import StorageReader, storage_reader_eligible + + +@pytest.fixture +def dispatch_runtime(): + if not getattr(blosc2.blosc2_ext, "portable_prefilter_available", lambda: False)(): + pytest.skip("Runtime does not provide portable prefilter dispatch") + + +@pytest.fixture +def dense_dispatch_runtime(dispatch_runtime): + if blosc2.IS_WASM: + pytest.skip("Dense chunk/prefilter dispatch is host-only; WASM uses bounded readers") + + +def kernel(source="def k(x, y):\n return x + (y - 1)\n", dtype="float64", output=None, jit=True): + author = blosc2.DSLKernel.from_source(source) + return blosc2.PortableKernel.from_json(author.export({"x": dtype, "y": dtype}, output or dtype), jit=jit) + + +def forbidden(*args, **kwargs): + pytest.fail("Unexpected evaluation route or execution replay") + + +def test_single_chunk_materializes_once(dense_dispatch_runtime, monkeypatch): + values = np.arange(100_000.0) + x = blosc2.asarray(values) + lazy = kernel().lazy({"x": x, "y": x}) + monkeypatch.setattr(StorageReader, "read", forbidden) + monkeypatch.setattr(blosc2.NDArray, "_execute_portable_prefilter", forbidden) + np.testing.assert_array_equal(lazy[:], values * 2 - 1) + assert lazy._source_execution_report["route"] == "single-chunk" + assert lazy._source_execution_report["input_buffer_bytes"] == 1_600_000 + assert lazy._source_execution_report["fp_flags"] == 0 + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("jit", [False, True]) +def test_multichunk_uses_portable_prefilter(dense_dispatch_runtime, monkeypatch, dtype, jit): + values = np.arange(2003, dtype=dtype) + x = blosc2.asarray(values, chunks=(1000,), blocks=(100,)) + lazy = kernel(dtype=dtype, jit=jit).lazy({"y": x, "x": x}) + monkeypatch.setattr(StorageReader, "read", forbidden) + monkeypatch.setattr(blosc2.PortableKernel, "evaluate_block", forbidden) + monkeypatch.setattr(blosc2.NDArray, "_set_pref_expr", forbidden) + np.testing.assert_array_equal(lazy[:], values + (values - 1)) + report = lazy._source_execution_report + assert report["route"] == "portable-prefilter" + assert report["evaluated_blocks"] == 3 # Tiny source blocks share one batch per chunk. + assert report["input_buffer_bytes"] <= 32 * 1024**2 + + +def test_prefilter_output_dtype_and_padding(dense_dispatch_runtime): + values = np.linspace(-1, 1, 2003) + x = blosc2.asarray(values, chunks=(1000,), blocks=(100,)) + native = kernel("def k(x, y):\n return x > y\n", output="bool") + y = blosc2.asarray(np.zeros_like(values), chunks=(1000,), blocks=(100,)) + lazy = native.lazy({"x": x, "y": y}) + np.testing.assert_array_equal(lazy[:], values > 0) + assert lazy._source_execution_report["evaluated_blocks"] == 3 + + +def test_partial_read_stays_bounded(dispatch_runtime, monkeypatch): + values = np.arange(100_000.0) + x = blosc2.asarray(values) + lazy = kernel().lazy({"x": x, "y": x}) + monkeypatch.setattr(blosc2.PortableKernel, "evaluate_block", forbidden) + monkeypatch.setattr(blosc2.NDArray, "_execute_portable_prefilter", forbidden) + np.testing.assert_array_equal(lazy[100:200], (values * 2 - 1)[100:200]) + assert lazy._source_execution_report["route"] == "bounded-readers" + + +def test_mismatched_layouts_stay_bounded(dispatch_runtime, monkeypatch): + values = np.arange(5003.0) + x = blosc2.asarray(values, chunks=(1000,), blocks=(100,)) + y = blosc2.asarray(values, chunks=(700,), blocks=(70,)) + lazy = kernel().lazy({"x": x, "y": y}) + monkeypatch.setattr(blosc2.PortableKernel, "evaluate_block", forbidden) + monkeypatch.setattr(blosc2.NDArray, "_execute_portable_prefilter", forbidden) + np.testing.assert_array_equal(lazy[:], values * 2 - 1) + assert lazy._source_execution_report["route"] == "bounded-readers" + + +def test_single_chunk_failure_never_replays(dense_dispatch_runtime, monkeypatch): + x = blosc2.asarray(np.arange(100.0)) + lazy = kernel().lazy({"x": x, "y": x}) + calls = [] + + def fail(*args, **kwargs): + calls.append(True) + raise ArithmeticError("Numerical execution failed") + + monkeypatch.setattr(blosc2.PortableKernel, "evaluate_block", fail) + monkeypatch.setattr(StorageReader, "read", forbidden) + monkeypatch.setattr(blosc2.NDArray, "_execute_portable_prefilter", forbidden) + with pytest.raises(ArithmeticError, match="Numerical execution failed"): + lazy[:] + assert len(calls) == 1 + + +def test_single_chunk_decoder_failure_never_replays(dense_dispatch_runtime, monkeypatch): + x = blosc2.asarray(np.arange(100.0)) + lazy = kernel().lazy({"x": x, "y": x}) + + def fail(*args, **kwargs): + raise OSError("Single-chunk decoding failed") + + monkeypatch.setattr(blosc2.SChunk, "decompress_chunk", fail) + monkeypatch.setattr(blosc2.PortableKernel, "evaluate_block", forbidden) + monkeypatch.setattr(StorageReader, "read", forbidden) + with pytest.raises(OSError, match="Single-chunk decoding failed"): + lazy[:] + + +def test_prefilter_failure_never_replays(dense_dispatch_runtime, monkeypatch): + x = blosc2.asarray(np.arange(2000.0), chunks=(1000,), blocks=(100,)) + lazy = kernel().lazy({"x": x, "y": x}) + + def fail(*args, **kwargs): + raise OSError("Prefilter storage execution failed") + + monkeypatch.setattr(blosc2.NDArray, "_execute_portable_prefilter", fail) + monkeypatch.setattr(blosc2.PortableKernel, "evaluate_block", forbidden) + monkeypatch.setattr(StorageReader, "read", forbidden) + with pytest.raises(OSError, match="Prefilter storage execution failed"): + lazy[:] + + +def test_native_prefilter_corrupt_layout_failure(dense_dispatch_runtime, monkeypatch): + import struct + + x = blosc2.asarray(np.arange(2000.0), chunks=(1000,), blocks=(100,)) + compressed = bytearray(x.schunk.get_chunk(0)) + struct.pack_into(" 0, x + 1e100, y)"]) +def test_checked_weak_conversion_metadata_rejects_retiling(dispatch_runtime, expression): + from types import SimpleNamespace + + dtype = np.dtype("float32") + metadata = SimpleNamespace( + source=f"def k(x, y):\n return {expression}\n", + input_dtypes={"x": dtype, "y": dtype}, + output_dtype=dtype, + inferred_dtype=dtype, + result_cardinality="elementwise", + context_ndim=0, + ) + assert not storage_reader_eligible(metadata) + + +@pytest.mark.parametrize("chunks", [1000, 3000]) +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("output", ["float", "bool"]) +def test_threadless_compressed_reads_use_bounded_readers( + dispatch_runtime, monkeypatch, chunks, dtype, output +): + values = np.linspace(-1, 1, 2003, dtype=dtype) + x = blosc2.asarray(values, chunks=(chunks,), blocks=(100,)) + boolean = output == "bool" + native = kernel( + "def k(x, y):\n return x > y\n" if boolean else "def k(x, y):\n return x + (y - 1)\n", + dtype=dtype, + output="bool" if boolean else dtype, + ) + lazy = native.lazy({"x": x, "y": x}) + # Exercise the real threadless dispatch gate even when this test runs on a host. + monkeypatch.setattr(blosc2, "IS_WASM", True) + monkeypatch.setattr(blosc2.PortableKernel, "evaluate_block", forbidden) + monkeypatch.setattr(blosc2.NDArray, "_execute_portable_prefilter", forbidden) + np.testing.assert_array_equal(lazy[:], values > values if boolean else values + (values - 1)) + assert lazy._source_execution_report["route"] == "bounded-readers" + + +def test_threadless_reader_failure_never_replays(dispatch_runtime, monkeypatch): + x = blosc2.asarray(np.arange(2003.0), chunks=(1000,), blocks=(100,)) + lazy = kernel().lazy({"x": x, "y": x}) + calls = [] + + def fail(*args, **kwargs): + calls.append(True) + raise OSError("Threadless storage read failed") + + monkeypatch.setattr(blosc2, "IS_WASM", True) + monkeypatch.setattr(StorageReader, "read", fail) + monkeypatch.setattr(blosc2.PortableKernel, "evaluate_block", forbidden) + monkeypatch.setattr(blosc2.NDArray, "_execute_portable_prefilter", forbidden) + with pytest.raises(OSError, match="Threadless storage read failed"): + lazy[:] + assert len(calls) == 1 diff --git a/tests/test_menudet_functions.py b/tests/test_menudet_functions.py new file mode 100644 index 000000000..a847248a8 --- /dev/null +++ b/tests/test_menudet_functions.py @@ -0,0 +1,158 @@ +"""Function contracts and scoped native floating-status integration.""" + +import json +import os +import sys +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path + +import numpy as np +import pytest + +import blosc2 +from tools import menudet_conformance as compat + + +def kernel(expression, dtype="float64", output=None, version="1.0"): + author = blosc2.DSLKernel.from_source(f"def k(x):\n return {expression}\n") + return blosc2.PortableKernel.from_json(author.export({"x": dtype}, output or dtype, version=version)) + + +@pytest.fixture(autouse=True) +def status_runtime(): + try: + kernel("isfinite(x)", output="bool") + except blosc2.PortableArtifactError as error: + if os.environ.get("MENUDET_NUMPY_FUNCTION_CORPUS"): + pytest.fail(f"Explicit M4 testing requires updated native function runtime: {error}") + pytest.skip("Installed native dependency does not implement M4 functions/status") + + +@pytest.mark.parametrize( + ("expression", "values", "flags"), + [ + ("sqrt(x)", [-1.0], 1), + ("log(x)", [0.0], 2), + ("exp(x)", [1000.0], 4), + ("exp(x)", [-1000.0], 8), + ("sqrt(x)", [4.0], 0), + ("log(x) + sqrt(x)", [-1.0, 0.0], 3), + ], +) +def test_status_and_raise_recovery(expression, values, flags): + k = kernel(expression) + result, status = k.evaluate({"x": np.array(values)}, return_status=True) + with np.errstate(all="ignore"): + expected = eval(expression, {"sqrt": np.sqrt, "log": np.log, "exp": np.exp, "x": np.array(values)}) + np.testing.assert_array_equal(result, expected) + if sys.platform == "emscripten": + assert status == {"supported": False, "flags": 0} + with pytest.raises(blosc2.PortableArtifactError, match="unsupported"): + k.evaluate({"x": np.array(values)}, fp_errors="raise") + elif flags: + assert status == {"supported": True, "flags": flags} + with pytest.raises(blosc2.PortableArtifactError, match="floating exception") as error: + k.evaluate({"x": np.array(values)}, fp_errors="raise") + assert error.value.fp_status == status + else: + assert status == {"supported": True, "flags": 0} + _result, clean = k.evaluate({"x": np.array([1.0])}, return_status=True) + assert clean["flags"] == 0 + + +def test_mask_and_unselected_where_do_not_report(): + k = kernel("sqrt(x)") + result, status = k.evaluate_block( + {"x": np.array([-1.0, 4.0])}, valid_mask=np.array([False, True]), return_status=True + ) + assert result[1] == 2 + assert status["flags"] == 0 + lazy = kernel("where(x > 0, sqrt(x), 0)") + result, status = lazy.evaluate( + {"x": np.array([-1.0, 4.0])}, + return_status=True, + fp_errors="ignore" if sys.platform == "emscripten" else "raise", + ) + np.testing.assert_array_equal(result, [0, 2]) + assert status["flags"] == 0 + + +def test_clear_and_explicit_block_aggregation(): + k = kernel("log(x)") + flags = 0 + for values, expected in [([-1.0], 1), ([0.0], 2), ([1.0], 0), ([], 0)]: + _result, status = k.evaluate({"x": np.array(values)}, return_status=True) + assert status == { + "supported": sys.platform != "emscripten", + "flags": 0 if sys.platform == "emscripten" else expected, + } + flags |= status["flags"] + assert flags == (0 if sys.platform == "emscripten" else 3) + + +def test_same_handle_thread_status_isolation(): + k = kernel("log(x)") + + def run(value): + return k.evaluate({"x": np.array([value])}, return_status=True)[1]["flags"] + + values = [-1.0, 0.0, 1.0] * 64 + if sys.platform == "emscripten": + assert list(map(run, values)) == [0] * len(values) + return + with ThreadPoolExecutor(max_workers=8) as pool: + assert list(pool.map(run, values)) == [1, 2, 0] * 64 + + +def test_policy_validation_and_default_profile(): + k = kernel("sqrt(x)") + with pytest.raises(ValueError, match="fp_errors"): + k.evaluate({"x": np.array([1.0])}, fp_errors="warn") + explicit = kernel("round(x)", version="1.0") + values, status = explicit.evaluate({"x": np.array([0.5])}, return_status=True) + assert values[0] == 0 + assert status["flags"] == 0 + new = kernel("round(x)") + assert new.evaluate({"x": np.array([0.5])})[0] == 0 + + +@pytest.mark.parametrize( + "name", ["minimum", "maximum", "isfinite", "isinf", "isnan", "signbit", "fabs", "absolute"] +) +def test_new_spellings_do_not_change_legacy_routing(name): + expression = f"{name}(x, x)" if name in {"minimum", "maximum"} else f"{name}(x)" + assert blosc2.blosc2_ext.me_output_dtype(expression, {"x": np.dtype("float64")}) is None + assert kernel(expression, version="1.0").schema_version == "1.0" + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +def test_extrema_zero_contract_and_nan_policy(dtype): + author = blosc2.DSLKernel.from_source("def k(x, y):\n return minimum(x, y)\n") + k = blosc2.PortableKernel.from_json(author.export({"x": dtype, "y": dtype}, dtype, version="1.0")) + result = k.evaluate( + { + "x": np.array([0.0, -0.0, np.nan, 1], dtype=dtype), + "y": np.array([-0.0, 0.0, 1, np.nan], dtype=dtype), + } + ) + assert np.signbit(result[:2]).all() + assert np.isnan(result[2:]).all() + artifact = json.loads(k.to_json()) + artifact["source"] = artifact["source"].replace("minimum", "fmin") + fmin = blosc2.PortableKernel.from_json(json.dumps(artifact)) + result = fmin.evaluate( + {"x": np.array([np.nan, 1], dtype=dtype), "y": np.array([1, np.nan], dtype=dtype)} + ) + np.testing.assert_array_equal(result, [1, 1]) + + +def test_shared_function_corpus(tmp_path): + corpus = os.environ.get("MENUDET_NUMPY_FUNCTION_CORPUS") + runner = os.environ.get("MENUDET_NUMPY_RUNNER") + if not corpus or not runner: + pytest.skip("Select authoritative function corpus and native runner explicitly") + report = compat.paired(json.loads(Path(corpus).read_text()), Path(runner), tmp_path) + compat.check(report) + if os.environ.get("MENUDET_REQUIRE_JIT"): + assert report["eligible_jit_cases"] > 0 + assert not any(row["jit_eligible"] for row in report["requests"]["off"]["native"]) diff --git a/tests/test_menudet_inverse_names.py b/tests/test_menudet_inverse_names.py new file mode 100644 index 000000000..f37ca13b4 --- /dev/null +++ b/tests/test_menudet_inverse_names.py @@ -0,0 +1,74 @@ +"""Canonical native inverse functions with NumPy frontend spellings preserved.""" + +import json +import os + +import numpy as np +import pytest + +import blosc2 +from blosc2.utils import MINIEXPR_FUNCTION_ALIASES, canonicalize_miniexpr_functions + + +@pytest.fixture +def native_runtime(): + try: + blosc2.DSLKernel.from_source("def k(x):\n return asin(x)\n").export( + {"x": "float64"}, "float64", version="1.0" + ) + except blosc2.PortableArtifactError as error: + if os.environ.get("MENUDET_REQUIRE_ARRAY_RUNTIME"): + pytest.fail(f"Explicit native qualification requires the updated runtime: {error}") + pytest.skip("Installed native dependency does not support Menudet 1.0") + + +@pytest.mark.parametrize("binary", [False, True]) +def test_normalization_preserves_non_calls(binary): + source = 'def k(arcsin):\n # arcsin(x)\n text = "arcsin(x)"\n return arcsinh(arcsin)\n' + expected = source.replace("return arcsinh(", "return asinh(") + if binary: + source, expected = source.encode(), expected.encode() + assert canonicalize_miniexpr_functions(source) == expected + assert canonicalize_miniexpr_functions("obj.arcsin(x)") == "obj.arcsin(x)" + assert canonicalize_miniexpr_functions("def arcsin(x):\n return x\n").startswith("def arcsin(") + assert canonicalize_miniexpr_functions(b"arcsin(\xff)") == b"arcsin(\xff)" + + +@pytest.mark.parametrize(("alias", "canonical"), MINIEXPR_FUNCTION_ALIASES.items()) +@pytest.mark.parametrize("version", ["1.0"]) +def test_authoring_normalizes_but_artifact_import_rejects_alias(native_runtime, alias, canonical, version): + arguments = "x, 1.0" if canonical == "atan2" else "x" + author = blosc2.DSLKernel.from_source(f"def k(x):\n return {alias}({arguments})\n") + assert f"{canonical}(" in author.dsl_source + artifact = json.loads(author.export({"x": "float64"}, "float64", version=version)) + assert f"{alias}(" not in artifact["source"] + kernel = blosc2.PortableKernel.from_json(json.dumps(artifact)) + values = np.array([1.0, 1.5]) if canonical == "acosh" else np.array([-0.25, 0.0, 0.25]) + expected = getattr(np, alias)(values, 1.0) if canonical == "atan2" else getattr(np, alias)(values) + np.testing.assert_allclose(kernel.evaluate({"x": values}), expected) + artifact["source"] = artifact["source"].replace(f"{canonical}(", f"{alias}(") + with pytest.raises(blosc2.PortableArtifactError): + blosc2.PortableKernel.from_json(json.dumps(artifact)) + + +@pytest.mark.parametrize(("alias", "canonical"), MINIEXPR_FUNCTION_ALIASES.items()) +def test_native_graph_numpy_spelling(native_runtime, native_graph_runtime, alias, canonical): + values = np.array([1.0, 1.5]) if canonical == "acosh" else np.array([-0.25, 0.0, 0.25]) + arguments = "x, 1.0" if canonical == "atan2" else "x" + with blosc2.expression_evaluation("safe"): + expr = blosc2.lazyexpr(f"np.{alias}({arguments})", operands={"x": values}) + result = expr.compute(_require_native=True) + expected = getattr(np, alias)(values, 1.0) if canonical == "atan2" else getattr(np, alias)(values) + np.testing.assert_allclose(result[:], expected) + + +def test_numpy_attribute_authoring(native_runtime): + @blosc2.dsl_kernel + def k(x): + return np.arcsin(x) + np.arctan2(x, 1.0) + + assert "asin(x)" in k.dsl_source + assert "atan2(x, 1.0)" in k.dsl_source + kernel = blosc2.PortableKernel.from_json(k.export({"x": "float64"}, "float64", version="1.0")) + values = np.array([-0.25, 0.0, 0.25]) + np.testing.assert_allclose(kernel.evaluate({"x": values}), np.arcsin(values) + np.arctan2(values, 1.0)) diff --git a/tests/test_menudet_jit.py b/tests/test_menudet_jit.py new file mode 100644 index 000000000..1b9c52164 --- /dev/null +++ b/tests/test_menudet_jit.py @@ -0,0 +1,395 @@ +"""Actual portable JIT execution, not accelerated-request interpreter fallback.""" + +import os +import shutil +import sys +from concurrent.futures import ThreadPoolExecutor + +import numpy as np +import pytest + +import blosc2 + + +def make(expression, dtype, *, jit, output=None, inputs=None): + inputs = inputs or {"x": dtype, "y": dtype} + source = f"def k({', '.join(inputs)}):\n return {expression}\n" + author = blosc2.DSLKernel.from_source(source) + artifact = author.export(inputs, output or dtype, version="1.0", casting="unsafe") + return blosc2.PortableKernel.from_json(artifact, jit=jit) + + +@pytest.fixture( + params=[ + "tcc", + pytest.param("cc", marks=pytest.mark.native_semantics), + pytest.param("clang", marks=pytest.mark.native_semantics), + ] +) +def backend(request, monkeypatch, tmp_path): + monkeypatch.setenv("ME_DSL_JIT_COMPILER", "cc" if request.param == "clang" else request.param) + monkeypatch.setenv("ME_DSL_JIT_CACHE_DIR", str(tmp_path)) + monkeypatch.delenv("CFLAGS", raising=False) + monkeypatch.delenv("ME_DSL_JIT_TCC_OPTIONS", raising=False) + if request.param == "cc": + compiler = os.environ.get("MENUDET_GCC", shutil.which("gcc-16") or shutil.which("gcc") or "cc") + monkeypatch.setenv("CC", compiler) + elif request.param == "clang": + compiler = os.environ.get("MENUDET_CLANG", shutil.which("clang")) + if not compiler: + pytest.skip("Clang is not installed") + monkeypatch.setenv("CC", compiler) + try: + probe = make("x + y", "float64", jit=True) + except blosc2.PortableArtifactError as error: + if "unsupported portable artifact version" not in str(error): + raise + if ( + os.environ.get("MENUDET_REQUIRE_JIT") == "1" + or os.environ.get("MENUDET_REQUIRE_GRAPH_RUNTIME") == "1" + ): + pytest.fail(str(error)) + pytest.skip("Installed miniexpr dependency does not implement Menudet 1.0") + if not probe.has_jit: + if os.environ.get("MENUDET_REQUIRE_JIT") == "1": + pytest.fail(f"{request.param} did not produce actual portable JIT") + pytest.skip(f"Portable {request.param} JIT unavailable in this runtime") + return request.param + + +@pytest.mark.parametrize("required", ["0", "1"]) +def test_backend_requirement_flag(monkeypatch, tmp_path, required): + from types import SimpleNamespace + + monkeypatch.setenv("MENUDET_REQUIRE_JIT", required) + monkeypatch.setattr( + sys.modules[__name__], "make", lambda *args, **kwargs: SimpleNamespace(has_jit=False) + ) + exception = pytest.fail.Exception if required == "1" else pytest.skip.Exception + with pytest.raises(exception): + backend.__wrapped__(SimpleNamespace(param="tcc"), monkeypatch, tmp_path) + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.native_semantics +@pytest.mark.parametrize( + ("expression", "boolean"), + [ + ("x * 2 + y / 3 - 1", False), + ("-x", False), + ("(x + y) * (x - y)", False), + ("x < y", True), + ("x <= y", True), + ("x > y", True), + ("x >= y", True), + ("x == y", True), + ("x != y", True), + ("x / y > 0", True), + ("where(x > 0, y / x, x * 2 + y)", False), + ("where(x != 0, where(y > 0, x / y, -x), y)", False), + ], +) +def test_bitwise_values_and_status(backend, dtype, expression, boolean): + accelerated = make(expression, dtype, jit=True, output="bool" if boolean else dtype) + reference = make(expression, dtype, jit=False, output="bool" if boolean else dtype) + assert accelerated.has_jit + assert not reference.has_jit + rng = np.random.Generator(np.random.PCG64(20261009)) + x = rng.normal(size=257).astype(dtype) + y = rng.normal(size=257).astype(dtype) + x[:9] = [0.0, -0.0, np.inf, -np.inf, np.nan, np.finfo(dtype).max, np.finfo(dtype).tiny, 1.0, -1.0] + y[:9] = [ + 0.0, + 0.0, + np.inf, + -np.inf, + 1.0, + np.finfo(dtype).max, + np.nextafter(np.array(0, dtype=dtype), np.array(1, dtype=dtype)), + 3.0, + 3.0, + ] + actual, actual_status = accelerated.evaluate({"x": x, "y": y}, return_status=True) + expected, expected_status = reference.evaluate({"x": x, "y": y}, return_status=True) + np.testing.assert_array_equal(actual, expected) + assert actual_status == expected_status + finite = ~np.isnan(expected) + assert actual[finite].tobytes() == expected[finite].tobytes() + for tile in (1, 17, 1024): + values = accelerated.evaluate_array({"x": x[::-1], "y": y[::-1]}, tile_items=tile) + np.testing.assert_array_equal(values, expected[::-1]) + + +@pytest.mark.skipif( + sys.platform == "emscripten", reason="Pyodide lacks the required FP status and threading support" +) +def test_lazy_mask_raise_recovery_and_threads(backend): + k = make("where(x != 0, y / x, y)", "float64", jit=True) + assert k.has_jit + bindings = {"x": np.array([0.0, 2.0]), "y": np.array([1.0, 4.0])} + values, status = k.evaluate(bindings, return_status=True, fp_errors="raise") + np.testing.assert_array_equal(values, [1.0, 2.0]) + assert status["flags"] == 0 + div = make("y / x", "float64", jit=True) + _, report = div.evaluate_array( + bindings, reduction="sum", where=np.array([False, True]), return_report=True + ) + assert report["fp_flags"] == 0 + with pytest.raises(blosc2.PortableArtifactError) as error: + div.evaluate(bindings, fp_errors="raise") + assert error.value.fp_status["flags"] == 2 + values, status = div.evaluate({"x": np.ones(2), "y": np.ones(2)}, return_status=True) + assert status["flags"] == 0 + with ThreadPoolExecutor(max_workers=4) as pool: + results = list(pool.map(lambda _: k.evaluate(bindings, return_status=True), range(16))) + assert all(status["flags"] == 0 for _, status in results) + + +@pytest.mark.skipif( + sys.platform == "emscripten", reason="mixed-domain TCC comparison lowering is unavailable on wasm32" +) +def test_fail_closed_and_casts(backend, monkeypatch): + for expression in ("x == -1", "x < -1"): + k = make(expression, "uint64", jit=True, output="bool") + assert k.has_jit # exact mixed-domain comparison, without C's unsigned promotion + np.testing.assert_array_equal( + k.evaluate({"x": np.array([0, 2**64 - 1], dtype="uint64"), "y": np.ones(2, dtype="uint64")}), + [False, False], + ) + k = make("x + y", "float32", jit=True, output="float64") + assert k.has_jit + x = np.array([1.0, 2.0**24], dtype="float32") + np.testing.assert_array_equal( + k.evaluate({"x": x, "y": np.ones(2, dtype="float32")}), + (x + np.ones(2, dtype="float32")).astype("float64"), + ) + monkeypatch.setenv("CFLAGS", "-ffast-math") + assert not make("x + y", "float64", jit=True).has_jit + + +@pytest.mark.parametrize( + ("expression", "dtype", "x", "y"), + [ + ("x // y", "int64", [-7, 7, -(2**63), 7, 0], [3, -3, -1, 0, 0]), + ("x << y", "int64", [-1, 7, -(2**63), 7, 7], [1, -1, 1, 64, 65]), + ("x // y", "float64", [-7, 7, -0.0, np.inf, -np.inf, np.nan, 1], [3, -3, 2, 1, np.inf, 3, 0]), + ], +) +@pytest.mark.native_semantics +def test_lowered_division_and_shift_guards(backend, expression, dtype, x, y): + # These routes are now lowered, not fail-closed fallbacks. Require actual + # compilation and retain exact values, signed zeros and status parity at + # zero divisors, signed overflow, nonfinite inputs and invalid shift counts. + compiled = make(expression, dtype, jit=True) + reference = make(expression, dtype, jit=False) + assert compiled.has_jit + assert not reference.has_jit + bindings = {"x": np.array(x, dtype=dtype), "y": np.array(y, dtype=dtype)} + actual, status = compiled.evaluate(bindings, return_status=True) + expected, expected_status = reference.evaluate(bindings, return_status=True) + assert status == expected_status + np.testing.assert_array_equal(actual, expected) + finite = ~np.isnan(expected) if dtype == "float64" else np.ones(expected.shape, dtype=bool) + assert actual[finite].tobytes() == expected[finite].tobytes() + + +def test_native_graph_acceleration_and_reuse(backend, native_graph_runtime): + from blosc2.native_graph import compile_plan + + x = np.arange(32, dtype="float64") + with blosc2.expression_evaluation("safe"): + expr = blosc2.lazyexpr("x * 2 + 1", {"x": x}) + result = expr.compute(_require_native=True, jit=True) + assert expr._native_execution_report["backend"] == "portable-jit" + np.testing.assert_array_equal(result[:], x * 2 + 1) + hits = compile_plan.cache_info().hits + x[:] = 4 + np.testing.assert_array_equal(expr.compute(_require_native=True, jit=True)[:], x * 2 + 1) + assert compile_plan.cache_info().hits > hits + + +@pytest.mark.native_semantics +def test_inactive_union_bits_do_not_raise(backend): + # Finite double whose low float32 word looks like a signaling NaN. The + # interpreter must not speculatively widen the inactive union member. + x = np.array([0x3FF000007F800001], dtype="uint64").view("float64") + for jit in (False, True): + k = make("x < y", "float64", jit=jit, output="bool") + _, status = k.evaluate({"x": x, "y": np.ones(1)}, return_status=True) + assert status["flags"] == 0 + + +@pytest.mark.native_semantics +def test_constant_operations_keep_runtime_diagnostics(backend): + for expression in ("x + (1.0 / 0.0)", "where(x > 0, 1.0 / 0.0, x)"): + compiled = make(expression, "float64", jit=True) + reference = make(expression, "float64", jit=False) + assert compiled.has_jit + for value in (-1.0, 1.0): + bindings = {"x": np.array([value]), "y": np.array([1.0])} + actual, status = compiled.evaluate(bindings, return_status=True) + expected, expected_status = reference.evaluate(bindings, return_status=True) + np.testing.assert_array_equal(actual, expected) + assert status == expected_status + + +@pytest.mark.native_semantics +def test_boolean_short_circuit_and_mixed_float_inputs(backend): + inputs = {"x": "float32", "y": "float64"} + k = make("where(x > 0, x + y, y)", "float64", jit=True, inputs=inputs) + assert k.has_jit + bindings = {"x": np.array([-1.0, 2.0], dtype="float32"), "y": np.array([3.0, 4.0])} + np.testing.assert_array_equal(k.evaluate(bindings), [3.0, 6.0]) + for expr in ("(x == 0) or (y / x > 1)", "(x != 0) and (y / x > 1)"): + k = make(expr, "float64", jit=True, output="bool") + assert k.has_jit + _, status = k.evaluate({"x": np.array([0.0]), "y": np.array([1.0])}, return_status=True) + assert status["flags"] == 0 + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("op", ["==", "!=", "<", "<=", ">", ">="]) +@pytest.mark.native_semantics +def test_inline_comparison_nan_payloads_and_status(backend, dtype, op): + # Construct payloads without floating arithmetic that could quiet sNaNs. + if dtype == "float32": + bits = [0x7FC00001, 0xFFC01234, 0x7F800001, 0xFF800123] + uint = "uint32" + else: + bits = [0x7FF8000000000001, 0xFFF8000000001234, 0x7FF0000000000001, 0xFFF0000000000123] + uint = "uint64" + nan = np.array(bits, dtype=uint).view(dtype) + compiled = make(f"x {op} y", dtype, jit=True, output="bool") + reference = make(f"x {op} y", dtype, jit=False, output="bool") + assert compiled.has_jit + for i in range(len(nan)): + value = nan[i : i + 1] + ordinary = np.array([0.0], dtype=dtype) + for x, y in ((value, ordinary), (ordinary, value), (value, value)): + bindings = {"x": x, "y": y} + actual, status = compiled.evaluate(bindings, return_status=True) + expected, expected_status = reference.evaluate(bindings, return_status=True) + np.testing.assert_array_equal(actual, expected) + assert status == expected_status + # Caller recovery and selected-lane masks must not leak NaN flags. + _, report = compiled.evaluate_array( + bindings, reduction="any", where=np.array([False]), return_report=True + ) + assert report["fp_flags"] == 0 + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.native_semantics +def test_inline_comparison_nan_in_unselected_branch(backend, dtype): + uint = "uint32" if dtype == "float32" else "uint64" + bits = 0x7F800001 if dtype == "float32" else 0x7FF0000000000001 + x = np.array([bits], dtype=uint).view(dtype) + k = make("where(y != 0, x > 0, y > 0)", dtype, jit=True, output="bool") + assert k.has_jit + values, status = k.evaluate({"x": x, "y": np.zeros(1, dtype=dtype)}, return_status=True) + np.testing.assert_array_equal(values, [False]) + assert status["flags"] == 0 + + +@pytest.mark.parametrize("dtype", ["int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64"]) +@pytest.mark.native_semantics +def test_modular_integer_lowering(backend, dtype): + info = np.iinfo(dtype) + x = np.array([info.min, info.max, 0, 1, info.max, info.min], dtype=dtype) + y = np.array([1, 1, info.max, info.max, info.max, info.min], dtype=dtype) + bindings = {"x": x, "y": y} + for expression in ("x + y", "x - y", "x * y", "-x", "where(x > y, x + y, x * y)", "x + 1"): + compiled = make(expression, dtype, jit=True) + reference = make(expression, dtype, jit=False) + assert compiled.has_jit, expression + actual, status = compiled.evaluate(bindings, return_status=True) + expected, expected_status = reference.evaluate(bindings, return_status=True) + assert actual.tobytes() == expected.tobytes() + assert status == expected_status + np.testing.assert_array_equal( + compiled.evaluate_array({"x": x[::-1], "y": y[::-1]}, tile_items=2), expected[::-1] + ) + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.native_semantics +def test_floor_division_quiet_nan_status(backend, dtype): + bindings = { + "x": np.array([np.nan, 3, -2, 0], dtype=dtype), + "y": np.array([2, np.nan, 4, 1], dtype=dtype), + } + with np.errstate(all="raise"): + expected = bindings["x"] // bindings["y"] + for jit in (False, True): + kernel = make("x // y", dtype, jit=jit) + if jit: + assert kernel.has_jit + actual, status = kernel.evaluate(bindings, return_status=True) + np.testing.assert_array_equal(actual, expected) + assert status["flags"] == 0 + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.native_semantics +def test_unary_math_lowering(backend, dtype): + x = np.array([-np.inf, -2, -0.0, 0.0, 0.25, 1.0, 2.0, np.inf, np.nan], dtype=dtype) + uint = "uint32" if dtype == "float32" else "uint64" + snan = np.array([0x7F800001 if dtype == "float32" else 0x7FF0000000000001], dtype=uint).view(dtype) + x = np.concatenate([x, snan]) + bindings = {"x": x, "y": np.ones_like(x)} + for expression in ( + "sin(x) + cos(x)", + "tan(x)", + "exp(x)", + "log(x)", + "sqrt(x)", + "floor(x)", + "ceil(x)", + "where(x > 0, log(x), y)", + ): + compiled = make(expression, dtype, jit=True) + reference = make(expression, dtype, jit=False) + assert compiled.has_jit, expression + actual, status = compiled.evaluate(bindings, return_status=True) + expected, expected_status = reference.evaluate(bindings, return_status=True) + np.testing.assert_array_equal(actual, expected) + finite = ~np.isnan(expected) + assert actual[finite].tobytes() == expected[finite].tobytes() + assert status == expected_status + _, report = compiled.evaluate_array( + bindings, reduction="sum", where=np.zeros(x.size, dtype=bool), return_report=True + ) + assert report["fp_flags"] == 0 + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize( + "body", + [ + " z = x * 2\n return z + 1\n", + " z = x + y\n z = z * 2\n return z\n", + " z = y / x\n return x\n", # unused assignment still raises + " if x > 0:\n return y / x\n else:\n return -x\n", + " if x > 0:\n z = y / x\n elif x < 0:\n z = x * 2\n else:\n z = y\n return z + 1\n", + " z = y\n if x != 0:\n z = y / x\n return z\n", + ], +) +@pytest.mark.native_semantics +def test_local_and_branch_lowering(backend, dtype, body): + artifact = blosc2.DSLKernel.from_source("def k(x, y):\n" + body).export( + {"x": dtype, "y": dtype}, dtype, version="1.0" + ) + compiled = blosc2.PortableKernel.from_json(artifact, jit=True) + reference = blosc2.PortableKernel.from_json(artifact, jit=False) + assert compiled.has_jit + bindings = { + "x": np.array([0.0, -0.0, -2.0, 3.0, np.inf, np.nan, 2**24], dtype=dtype), + "y": np.array([1.0, 2.0, 3.0, 4.0, np.inf, 5.0, 1.0], dtype=dtype), + } + actual, status = compiled.evaluate(bindings, return_status=True) + expected, expected_status = reference.evaluate(bindings, return_status=True) + np.testing.assert_array_equal(actual, expected) + assert status == expected_status + finite = ~np.isnan(expected) + assert actual[finite].tobytes() == expected[finite].tobytes() + np.testing.assert_array_equal(compiled.evaluate_array(bindings, tile_items=2), expected) diff --git a/tests/test_menudet_math_vectors.py b/tests/test_menudet_math_vectors.py new file mode 100644 index 000000000..e0211d9c6 --- /dev/null +++ b/tests/test_menudet_math_vectors.py @@ -0,0 +1,27 @@ +"""Certification references must follow the public Menudet numerical profile.""" + +import json +from pathlib import Path + +import numpy as np +import pytest + +VECTORS = Path(__file__).parents[1] / "scripts" / "menudet_math_vectors.json" +REMAINDERS = [case for case in json.loads(VECTORS.read_text())["cases"] if case["function"] == "remainder"] + + +@pytest.mark.parametrize("case", REMAINDERS) +def test_remainder_reference_uses_divisor_sign(case): + x, y = [np.asarray(float.fromhex(value), dtype=case["dtype"]) for value in case["inputs"]] + assert float(np.remainder(x, y)).hex() == case["expected"] + assert case["max_ulp"] == 0 + + +def test_remainder_reference_covers_all_operand_signs(): + for dtype in ("float32", "float64"): + signs = { + tuple(float.fromhex(value) < 0 for value in case["inputs"]) + for case in REMAINDERS + if case["dtype"] == dtype + } + assert signs == {(False, False), (False, True), (True, False), (True, True)} diff --git a/tests/test_menudet_native_graph.py b/tests/test_menudet_native_graph.py new file mode 100644 index 000000000..e399bf31c --- /dev/null +++ b/tests/test_menudet_native_graph.py @@ -0,0 +1,129 @@ +"""Native-required graph execution, plan reuse and NumExpr-unavailable deployment.""" + +import os +import subprocess +import sys + +import numpy as np +import pytest + +import blosc2 +from blosc2.expression_graph import ExpressionGraph +from blosc2.native_graph import compile_plan + + +@pytest.fixture(autouse=True) +def array_runtime(native_graph_runtime): + from blosc2.dsl_kernel import DSLKernel + + try: + source = DSLKernel.from_source("def k(x):\n return x\n") + plan = blosc2.PortableKernel.from_json(source.export({"x": "float64"}, "float64", version="1.0")) + plan.evaluate_array({"x": np.ones(1)}) + except blosc2.PortableArtifactError as error: + if os.environ.get("MENUDET_REQUIRE_ARRAY_RUNTIME"): + pytest.fail(str(error)) + pytest.skip("Installed dependency does not implement native logical arrays") + + +@pytest.mark.parametrize("dtype", ["int8", "int64", "uint64", "float32", "float64"]) +def test_required_graph_no_fallback_and_plan_reuse(monkeypatch, dtype): + x = np.arange(60).reshape(10, 6).astype(dtype) + y = np.ones((1, 6), dtype=dtype) + with blosc2.expression_evaluation("safe"): + expr = blosc2.lazyexpr("x * 2 + y", {"x": x, "y": y}) + + def forbidden(*args, **kwargs): + pytest.fail("Python/NumExpr numerical fallback occurred") + + import importlib + + module = importlib.import_module("blosc2.lazyexpr") + monkeypatch.setattr(module, "ne_evaluate", forbidden) + monkeypatch.setattr(ExpressionGraph, "evaluate", forbidden) + result = expr.compute(_require_native=True) + np.testing.assert_array_equal(result[:], x * 2 + y) + previous = compile_plan.cache_info().hits + x[:] = 3 + np.testing.assert_array_equal(expr.compute(_require_native=True)[:], x * 2 + y) + assert compile_plan.cache_info().hits > previous + assert expr._native_execution_report["backend"] == "portable-interpreter" + + +def test_partial_reads_and_reductions(): + x = np.arange(60.0).reshape(10, 6) + y = np.ones((1, 6)) + with blosc2.expression_evaluation("safe"): + expr = blosc2.lazyexpr("x + y", {"x": x, "y": y}) + np.testing.assert_array_equal( + expr.compute((slice(2, 8, 2), slice(None, None, -1)), _require_native=True)[:], (x + y)[2:8:2, ::-1] + ) + for op in ("sum", "prod", "min", "max", "any", "all"): + np.testing.assert_array_equal( + getattr(expr, op)(axis=0, _require_native=True), getattr(np, op)(x + y, axis=0) + ) + + +def test_root_reduction_and_export(tmp_path): + x = blosc2.asarray( + np.arange(24.0).reshape(4, 6), urlpath=tmp_path / "input.b2nd", chunks=(2, 6), blocks=(1, 3) + ) + with blosc2.expression_evaluation("safe"): + expr = blosc2.lazyexpr("sum(x * 2, axis=-1, keepdims=True)", {"x": x}) + elementwise = blosc2.lazyexpr("x * 2", {"x": x}) + np.testing.assert_array_equal( + expr.compute(_require_native=True), np.sum(x[:] * 2, axis=-1, keepdims=True) + ) + with pytest.raises(ValueError, match="Root"): + expr.native_kernel() + plan = elementwise.native_kernel() + inputs = {name: value for name, value in elementwise.operands.items() if name in plan.input_dtypes} + portable = plan.lazy(inputs, partitions=(2, 3)) + portable.save(tmp_path / "plan.b2nd") + loaded = blosc2.open(tmp_path / "plan.b2nd") + np.testing.assert_array_equal(loaded[:], x[:] * 2) + + +def test_unsupported_rejects_before_destination_write(tmp_path): + with blosc2.expression_evaluation("safe"): + expr = blosc2.lazyexpr("cumsum(x)", {"x": np.arange(8.0)}) + target = tmp_path / "output.b2nd" + with pytest.raises((ValueError, blosc2.PortableArtifactError)): + expr.compute(_require_native=True, urlpath=target) + assert not target.exists() + + +@pytest.mark.skipif(sys.platform == "emscripten", reason="Pyodide does not support subprocesses") +def test_numexpr_unavailable_subprocess(tmp_path): + script = r""" +import importlib.abc, sys +class Block(importlib.abc.MetaPathFinder): + def find_spec(self, fullname, *args): + if fullname == 'numexpr' or fullname.startswith('numexpr.'): + raise ModuleNotFoundError('NumExpr deliberately unavailable', name='numexpr') +sys.meta_path.insert(0, Block()) +import blosc2, numpy as np +assert blosc2.numexpr is None +with blosc2.expression_evaluation('safe'): + x = blosc2.asarray(np.arange(24.).reshape(4,6)) + e = blosc2.lazyexpr('sqrt(x) + 2', {'x':x}) + result = e.compute(_require_native=True) + np.testing.assert_allclose(result[:], np.sqrt(x[:]) + 2) + np.testing.assert_allclose(e.sum(axis=0, _require_native=True), np.sum(np.sqrt(x[:]) + 2,axis=0)) + plan = e.native_kernel() + imported = blosc2.PortableKernel.from_json(plan.to_json()) + bindings = {name:value[()] for name,value in e.operands.items() if name in imported.input_dtypes} + np.testing.assert_allclose(imported.evaluate_array(bindings), np.sqrt(x[:]) + 2) + from pathlib import Path + root = Path(sys.argv[1]) + stored = blosc2.asarray(x[:], urlpath=root/'input.b2nd') + e = blosc2.lazyexpr('sqrt(x) + 2', {'x':stored}) + plan = e.native_kernel() + bindings = {name:value for name,value in e.operands.items() if name in plan.input_dtypes} + plan.lazy(bindings, partitions=(2,3)).save(root/'portable.b2nd') + restored = blosc2.open(root/'portable.b2nd', deserialize='safe') + np.testing.assert_allclose(restored[:], np.sqrt(stored[:])+2) +assert not any(n == 'numexpr' or n.startswith('numexpr.') for n in sys.modules) +""" + result = subprocess.run([sys.executable, "-c", script, str(tmp_path)], capture_output=True, text=True) + assert result.returncode == 0, result.stdout + result.stderr diff --git a/tests/test_menudet_numpy_compat.py b/tests/test_menudet_numpy_compat.py new file mode 100644 index 000000000..45acdaefd --- /dev/null +++ b/tests/test_menudet_numpy_compat.py @@ -0,0 +1,157 @@ +"""Checkpoint tooling tests; shared native corpus must be selected explicitly.""" + +import importlib.util +import json +import os +import subprocess +from pathlib import Path + +import numpy as np +import pytest + +import blosc2 + +spec = importlib.util.spec_from_file_location( + "menudet_numpy_compat", Path(__file__).resolve().parents[1] / "tools" / "menudet_numpy_compat.py" +) +compat = importlib.util.module_from_spec(spec) +spec.loader.exec_module(compat) + + +@pytest.mark.parametrize("dtype", ["int64", "uint64", "float32", "float64", "bool"]) +def test_vector_bits_roundtrip(dtype): + if dtype == "int64": + values = [-(2**63), 2**63 - 1, 2**53 + 1] + elif dtype == "uint64": + values = [0, 2**64 - 1, 2**53 + 1] + elif dtype == "bool": + values = [True, False] + else: + values = [-0.0, 0.0, np.inf, -np.inf, np.nan] + array = np.array(values, dtype=dtype) + assert compat.decode(compat.buffer(array)).tobytes() == array.tobytes() + scalar = array[:1].reshape(()) + assert compat.decode(compat.buffer(scalar)).shape == () + + +def test_generator_requires_pinned_numpy(monkeypatch): + monkeypatch.setattr(np, "__version__", "secondary-version") + with pytest.raises(RuntimeError, match=r"requires NumPy 2\.5\.3"): + compat.generate() + + +def test_initial_array_inventory(): + add = blosc2.PortableKernel.from_json( + blosc2.DSLKernel.from_source("def k(x, y):\n return x + y\n").export( + {"x": "float32", "y": "float32"}, "float32" + ), + jit=False, + ) + x = np.array([[1], [2]], dtype="float32") + y = np.array([[2, 3, 4]], dtype="float32") + assert (x + y).shape == (2, 3) + with pytest.raises(blosc2.PortableArtifactError, match="binding_error"): + add.evaluate({"x": x, "y": y}) + block_sum = blosc2.PortableKernel.from_json( + blosc2.DSLKernel.from_source("def k(x):\n return block_sum(x)\n").export( + {"x": "int8"}, "int64", cardinality="block_scalar" + ), + jit=False, + ) + values = np.arange(6, dtype="int8").reshape(2, 3) + actual = block_sum.evaluate({"x": values}) + assert actual.shape == () + assert actual.dtype == np.dtype("int64") + assert actual == 15 + np.testing.assert_array_equal(np.sum(values, axis=1), [3, 12]) + identity = blosc2.PortableKernel.from_json( + blosc2.DSLKernel.from_source("def k(x):\n return x\n").export({"x": "float32"}, "float32"), + jit=False, + ) + view = np.arange(8, dtype="float32")[::-2] + np.testing.assert_array_equal(identity.evaluate({"x": view}), view) + + +@pytest.mark.parametrize("dtype", ["float16"]) +def test_inventory_unsupported_dtypes(dtype): + with pytest.raises(blosc2.PortableArtifactError, match="unsupported_requirement"): + blosc2.DSLKernel.from_source("def k(x):\n return x\n").export({"x": dtype}, dtype) + + +@pytest.mark.parametrize("dtype", ["complex64", "complex128"]) +def test_inventory_complex_dtypes(dtype): + values = np.array([1 + 2j, -3 + 0.5j, 0 + 0j], dtype=dtype) + kernel = blosc2.PortableKernel.from_json( + blosc2.DSLKernel.from_source("def k(x):\n return x * x + 1\n").export({"x": dtype}, dtype), + jit=False, + ) + np.testing.assert_allclose(kernel.evaluate({"x": values}), values * values + 1) + + +def test_shared_checkpoint_corpus(monkeypatch): + path = os.environ.get("MENUDET_NUMPY_CORPUS") + if not path: + pytest.skip("Set MENUDET_NUMPY_CORPUS to the authoritative miniexpr vectors.json") + corpus = json.loads(Path(path).read_text()) + assert corpus["schema_version"] == "menudet-numpy-vectors-1" + assert corpus["reference"]["numpy"] == "2.5.3" + import numexpr + + def forbidden(*args, **kwargs): + raise AssertionError("Portable integration must not call NumExpr") + + monkeypatch.setattr(numexpr, "evaluate", forbidden) + report = compat.integrate(corpus, repeats=2) + compat.check_baseline(corpus, report) + if np.__version__ == "2.5.3": + assert compat.reference_drift(corpus)["differences"] == [] + regenerated = compat.generate() + for actual, expected in zip(regenerated["cases"], corpus["cases"], strict=True): + assert actual["id"] == expected["id"] + assert actual["expected"] == expected["expected"] + assert actual["artifact"] == expected["artifact"] + for case in corpus["cases"]: + artifact = json.loads(case["artifact"]) + author = blosc2.DSLKernel.from_source(artifact["source"]) + signature = {item["name"]: item["dtype"] for item in artifact["inputs"]} + constants = {item["name"]: compat.decode(item)[()] for item in case.get("scalar_operands", [])} + if case["baseline"]["status"] == -3: + with pytest.raises(blosc2.PortableArtifactError, match="invalid_source"): + author.export(signature, artifact["output"]["dtype"], constants=constants) + else: + exported = json.loads(author.export(signature, artifact["output"]["dtype"], constants=constants)) + assert exported["source"] == artifact["source"] + assert exported["constants"] == artifact["constants"] + artifact["language"]["version"] = "1.1" + with pytest.raises(blosc2.PortableArtifactError, match="unsupported"): + blosc2.PortableKernel.from_json(json.dumps(artifact), jit=False) + artifact["language"]["version"] = "1.0" + artifact["schema_version"] = "1.1" + with pytest.raises(blosc2.PortableArtifactError, match="unsupported"): + blosc2.PortableKernel.from_json(json.dumps(artifact), jit=False) + + +@pytest.mark.parametrize("corruption", ["schema", "semantic_revision", "hex", "extent", "baseline"]) +def test_native_vector_rejections(tmp_path, corruption): + runner = os.environ.get("MENUDET_NUMPY_RUNNER") + path = os.environ.get("MENUDET_NUMPY_CORPUS") + if not runner or not path: + pytest.skip("Set MENUDET_NUMPY_RUNNER and MENUDET_NUMPY_CORPUS for standalone runner checks") + corpus = json.loads(Path(path).read_text()) + # A successful case must reach buffer decoding rather than reject at compile. + corpus["cases"] = [next(case for case in corpus["cases"] if case["id"] == "float32-weak-literal")] + case = corpus["cases"][0] + if corruption == "schema": + corpus["schema_version"] = "future" + elif corruption == "semantic_revision": + case["semantic_revision"] = "future" + elif corruption == "hex": + case["inputs"][0]["hex"] = "zz" + elif corruption == "extent": + case["inputs"][0]["shape"] = [2**63] + else: + case["baseline"]["hex"] = "00" + vector = tmp_path / "corrupted.json" + vector.write_text(json.dumps(corpus)) + result = subprocess.run([runner, str(vector)], capture_output=True, text=True, check=False) + assert result.returncode == 1, result diff --git a/tests/test_menudet_wasm.py b/tests/test_menudet_wasm.py new file mode 100644 index 000000000..141b3ac24 --- /dev/null +++ b/tests/test_menudet_wasm.py @@ -0,0 +1,221 @@ +"""Public-API qualification of the bridge-free Menudet JIT on wasm32.""" + +from __future__ import annotations + +import numpy as np +import pytest + +import blosc2 + +pytestmark = pytest.mark.skipif(not getattr(blosc2, "IS_WASM", False), reason="wasm32 only") + + +def make(expression, dtype, *, inputs=None, output=None, jit=True): + inputs = inputs or {"x": dtype, "y": dtype} + source = f"def k({', '.join(inputs)}):\n return {expression}\n" + artifact = blosc2.DSLKernel.from_source(source).export( + inputs, output or dtype, version="1.0", casting="unsafe" + ) + return blosc2.PortableKernel.from_json(artifact, jit=jit) + + +def require_helpers(): + if not getattr(blosc2, "_WASM_MINIEXPR_ENABLED", False): + pytest.skip("wasm JIT helpers are unavailable in this runtime") + + +def assert_same(actual, expected): + assert np.array_equal(actual, expected, equal_nan=True) + non_nan = ~np.isnan(expected) + assert actual[non_nan].tobytes() == expected[non_nan].tobytes() + + +def test_exact_integer_boundaries_and_control_flow(): + require_helpers() + x = np.array([-(2**63), 2**63 - 1, 2**53 + 1, -1, 0, 2**62], dtype="int64") + y = np.array([-1, 1, 7, 2**63 - 1, 0, 3], dtype="int64") + for expression in ("x + y", "x - y", "x * y", "-x"): + accelerated = make(expression, "int64") + reference = make(expression, "int64", jit=False) + assert accelerated.has_jit + assert not reference.has_jit + assert_same( + accelerated.evaluate({"x": x, "y": y}), + reference.evaluate({"x": x, "y": y}), + ) + + ux = np.array([2**64 - 1, 2**63, 2**53 + 1, 1], dtype="uint64") + uy = np.array([1, 7, 9, 2**64 - 1], dtype="uint64") + for expression in ("x + y", "x - y", "x * y"): + accelerated = make(expression, "uint64") + assert accelerated.has_jit + assert_same( + accelerated.evaluate({"x": ux, "y": uy}), + make(expression, "uint64", jit=False).evaluate({"x": ux, "y": uy}), + ) + + xf = np.array([-3.0, -0.0, 0.0, 1.0, 2.5, np.nan], dtype="float64") + yf = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], dtype="float64") + for expression in ( + "x * 1.25 + y * 0.75", + "where(x > 0.0, x + y, x - y)", + "where(x != 0.0, where(y > 0.0, x / y, -x), y)", + ): + accelerated = make(expression, "float64") + assert accelerated.has_jit + assert_same( + accelerated.evaluate({"x": xf, "y": yf}), + make(expression, "float64", jit=False).evaluate({"x": xf, "y": yf}), + ) + + loop = "def k(x, y):\n v = x\n for i in range(16):\n v = v + y\n return v\n" + artifact = blosc2.DSLKernel.from_source(loop).export( + {"x": "float64", "y": "float64"}, "float64", version="1.0", casting="unsafe" + ) + accelerated = blosc2.PortableKernel.from_json(artifact, jit=True) + assert accelerated.has_jit + assert_same( + accelerated.evaluate({"x": xf, "y": yf}), + blosc2.PortableKernel.from_json(artifact, jit=False).evaluate({"x": xf, "y": yf}), + ) + + +def test_masks_tiles_and_reuse(): + require_helpers() + x = np.array([1.0, 100.0, -2.0, 4.0, 0.0, np.nan], dtype="float64") + y = np.array([3.0, 100.0, 1.0, -1.0, 0.0, 1.0], dtype="float64") + accelerated = make("x * 2.0 + y", "float64") + reference = make("x * 2.0 + y", "float64", jit=False) + assert accelerated.has_jit + + mask = np.array([1, 0, 1, 1, 0, 1], dtype=np.uint8) + actual = accelerated.evaluate_block({"x": x, "y": y}, block_shape=x.shape, valid_mask=mask) + expected = reference.evaluate_block({"x": x, "y": y}, block_shape=x.shape, valid_mask=mask) + active = mask.astype(bool) + assert_same(actual[active], expected[active]) + + for tile in (1, 3, 17, 1024): + assert_same( + accelerated.evaluate_array({"x": x, "y": y}, tile_items=tile), + reference.evaluate_array({"x": x, "y": y}, tile_items=tile), + ) + + # Reusing the same artifact should keep returning an executable JIT kernel. + source = "def k(x, y):\n return x * y + 1.0\n" + artifact = blosc2.DSLKernel.from_source(source).export( + {"x": "float64", "y": "float64"}, "float64", version="1.0", casting="unsafe" + ) + for _ in range(8): + kernel = blosc2.PortableKernel.from_json(artifact, jit=True) + assert kernel.has_jit + assert_same(kernel.evaluate({"x": x, "y": y}), x * y + 1.0) + + +def test_unaligned_views_are_normalized(): + require_helpers() + x = np.array([1.0, 2.0, 3.0, 4.0], dtype=np.float64) + y = np.array([10.0, 20.0, 30.0, 40.0], dtype=np.float64) + raw_x = np.zeros(1 + x.nbytes, dtype=np.uint8) + raw_y = np.zeros(1 + y.nbytes, dtype=np.uint8) + raw_x[1:] = x.view(np.uint8) + raw_y[1:] = y.view(np.uint8) + unaligned_x = np.frombuffer(raw_x[1:], dtype=np.float64) + unaligned_y = np.frombuffer(raw_y[1:], dtype=np.float64) + assert not unaligned_x.flags.aligned + assert not unaligned_y.flags.aligned + + accelerated = make("x * 2.0 + y", "float64") + reference = make("x * 2.0 + y", "float64", jit=False) + assert accelerated.has_jit + assert_same( + accelerated.evaluate({"x": unaligned_x, "y": unaligned_y}), + reference.evaluate({"x": unaligned_x, "y": unaligned_y}), + ) + + +@pytest.mark.parametrize( + ("expression", "dtype", "output", "x", "y"), + [ + ("x + sin(y)", "float64", "float64", [1.0, 2.0, 3.0, 4.0], [0.0, 1.0, 2.0, 3.0]), + ("isnan(x)", "float64", "bool", [1.0, np.nan, np.inf, -0.0], [0.0] * 4), + ("int(x)", "float64", "int64", [1.5, -2.5, 0.0, 4.0], [0.0] * 4), + ( + "x < -1", + "uint64", + "bool", + [0, 1, 2**64 - 1, 2**63], + [1, 1, 1, 1], + ), + ], +) +def test_unsupported_bridges_fall_back(expression, dtype, output, x, y): + require_helpers() + accelerated = make(expression, dtype, output=output) + reference = make(expression, dtype, output=output, jit=False) + assert not accelerated.has_jit + bindings = {"x": np.array(x, dtype=dtype), "y": np.array(y, dtype=dtype)} + assert_same(accelerated.evaluate(bindings), reference.evaluate(bindings)) + + +@blosc2.menudet(require_jit=True) +def _decorated_affine(x: np.float64, y: np.float64) -> np.float64: + return x * 1.25 + y * 0.75 + + +_CAPTURE_SCALE = np.float64(1.5) + + +@blosc2.menudet(require_jit=True) +def _captured_affine(x: np.float64, y: np.float64) -> np.float64: + return x * _CAPTURE_SCALE + y + + +def test_scalar_capture_through_decorator(): + require_helpers() + x = np.arange(8, dtype=np.float64) + y = np.ones(8, dtype=np.float64) + kernel = _captured_affine.specialize(x, y) + assert kernel.has_jit + assert_same(_captured_affine(x, y)[:], x * _CAPTURE_SCALE + y) + + +def test_decorator_requires_actual_jit(): + require_helpers() + x = np.arange(8, dtype=np.float64) + y = np.ones(8, dtype=np.float64) + kernel = _decorated_affine.specialize(x, y) + assert kernel.has_jit + assert_same(_decorated_affine(x, y)[:], x * 1.25 + y * 0.75) + + +def test_nd_context_falls_back(): + require_helpers() + source = "def k(x, y):\n return x + _flat_idx + y\n" + artifact = blosc2.DSLKernel.from_source(source).export( + {"x": "float64", "y": "float64"}, "float64", version="1.0", casting="unsafe", ndim=2 + ) + accelerated = blosc2.PortableKernel.from_json(artifact, jit=True) + reference = blosc2.PortableKernel.from_json(artifact, jit=False) + assert not accelerated.has_jit + x = np.arange(4, dtype=np.float64).reshape(2, 2) + y = np.ones((2, 2), dtype=np.float64) + actual = accelerated.evaluate_block( + {"x": x, "y": y}, block_shape=(2, 2), logical_shape=(2, 2), block_origin=(0, 0) + ) + expected = reference.evaluate_block( + {"x": x, "y": y}, block_shape=(2, 2), logical_shape=(2, 2), block_origin=(0, 0) + ) + assert_same(actual, expected) + + +def test_reduction_falls_back(): + require_helpers() + source = "def k(x):\n return block_sum(x)\n" + artifact = blosc2.DSLKernel.from_source(source).export( + {"x": "float64"}, "float64", version="1.0", casting="unsafe", cardinality="block_scalar" + ) + accelerated = blosc2.PortableKernel.from_json(artifact, jit=True) + reference = blosc2.PortableKernel.from_json(artifact, jit=False) + assert not accelerated.has_jit + x = np.array([1.0, 2.0, 3.0, 4.0], dtype="float64") + assert_same(accelerated.evaluate({"x": x}), reference.evaluate({"x": x})) diff --git a/tests/test_native_expression_ingestion.py b/tests/test_native_expression_ingestion.py new file mode 100644 index 000000000..b904200be --- /dev/null +++ b/tests/test_native_expression_ingestion.py @@ -0,0 +1,147 @@ +"""Automatic lowering uses native text only for a proven shared grammar subset.""" + +import numpy as np +import pytest + +import blosc2 +import blosc2.native_graph as native + + +@pytest.mark.parametrize("dtype", ["int8", "uint64", "float32", "float64", "bool"]) +@pytest.mark.parametrize("backend", ["tcc", "cc"]) +def test_native_expression_ingestion_bypasses_adapter(native_graph_runtime, monkeypatch, dtype, backend): + monkeypatch.setenv("ME_DSL_JIT_COMPILER", backend) + values = np.arange(12).reshape(3, 4).astype(dtype) + y = np.ones((1, 4), dtype=dtype) + source = "x == y" if dtype == "bool" else "x + (y - 1)" + expr = blosc2.lazyexpr(source, {"x": values, "y": y}) + + def forbidden(*args, **kwargs): + pytest.fail("Eligible native text expression constructed Python graph nodes") + + monkeypatch.setattr(native.GraphAdapter, "visit", forbidden) + plan, arrays, reduction = native.lower_native_graph(expr, jit=True) + assert plan._frontend == "native-expression" + assert not reduction + expected = values == y if dtype == "bool" else values + (y - 1) + np.testing.assert_array_equal(plan.evaluate(arrays), expected) + + +@pytest.mark.parametrize( + "source", + [ + "x + 0x10", + "x + 1_000", + "x + (-0.0)", + "x * -2 + 1", + "x & 3 == 1", + "sum(x + 1)", + "sum(x + 1, axis=0, keepdims=True)", + "max(x, initial=-1)", + ], +) +def test_text_and_json_frontend_parity(native_graph_runtime, monkeypatch, source): + values = np.arange(12, dtype=np.int32).reshape(3, 4) + expr = blosc2.LazyExpr._new_expr(source, {"x": values}, guess=False) + text, inputs, reduction = native.lower_native_graph(expr) + assert text._frontend == "native-expression" + monkeypatch.setattr(native, "_native_text_expression", lambda expression: None) + declarative, old_inputs, old_reduction = native.lower_native_graph(expr) + assert declarative._frontend == "declarative-json" + assert reduction == old_reduction + expected, old_report = declarative.evaluate(old_inputs, return_report=True) + result, report = text.evaluate(inputs, return_report=True) + assert result.dtype == expected.dtype + np.testing.assert_array_equal(result, expected) + assert report["fp_flags"] == old_report["fp_flags"] + + +@pytest.mark.parametrize("capture", [1, np.int32(1), np.float32(1)]) +def test_scalar_captures_keep_declarative_frontend(native_graph_runtime, capture): + expr = blosc2.lazyexpr("x + c", {"x": np.arange(6, dtype=np.float32), "c": capture}) + plan, arrays, reduction = native.lower_native_graph(expr) + assert plan._frontend == "declarative-json" + assert not reduction + np.testing.assert_array_equal(plan.evaluate(arrays), np.arange(6, dtype=np.float32) + capture) + + +@pytest.mark.parametrize("source", ["x.sum()", "sum(x, dtype='int64')", "np.sum(x)", "sum(x) + x"]) +def test_unqualified_syntax_keeps_declarative_frontend(native_graph_runtime, source): + expr = blosc2.LazyExpr._new_expr(source, {"x": np.arange(6, dtype=np.int32)}, guess=False) + plan, _, _ = native.lower_native_graph(expr) + assert plan._frontend == "declarative-json" + + +def test_method_options_keep_declarative_frontend(native_graph_runtime): + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(6, dtype=np.float32)}) + plan, arrays, reduction = native.lower_native_graph( + expr, reduction_options={"reduction": "sum", "axis": 0} + ) + assert plan._frontend == "declarative-json" + assert reduction + assert plan.evaluate(arrays) == 21 + + +def test_automatic_execution_reports_native_frontend(native_graph_runtime): + values = np.arange(100_000, dtype=np.float64) + expr = blosc2.lazyexpr("x + 1", {"x": values}) + prepared = native.prepare_native_first(expr, ()) + if prepared is None: + pytest.skip("Automatic native execution requires graph JIT") + np.testing.assert_array_equal(expr[:], values + 1) + assert expr._native_execution_report["frontend"] == "native-expression" + + +def test_native_text_ignores_unused_capture(native_graph_runtime): + values = np.arange(6, dtype=np.float32) + expr = blosc2.LazyExpr._new_expr("x + 1", {"x": values, "unused": np.int32(3)}, guess=False) + plan, arrays, _ = native.lower_native_graph(expr) + assert plan._frontend == "native-expression" + assert tuple(arrays) == ("x",) + np.testing.assert_array_equal(plan.evaluate(arrays), values + 1) + + +@pytest.mark.parametrize("name", ["true", "false", "null"]) +def test_native_lexer_reserved_names_keep_adapter(native_graph_runtime, name): + values = np.arange(6, dtype=np.float32) + expr = blosc2.LazyExpr._new_expr(f"{name} + 1", {name: values}, guess=False) + plan, _, _ = native.lower_native_graph(expr) + assert plan._frontend == "declarative-json" + + +def test_native_text_rejects_unicode_binding_syntax(): + assert native._native_text_expression("α + 1") is None + + +def test_native_text_cache_uses_dtype_and_jit_configuration(native_graph_runtime, monkeypatch): + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(6, dtype=np.float32)}) + first, _, _ = native.lower_native_graph(expr) + name = next(iter(expr.operands)) + expr.operands[name][:] = 0 + second, arrays, _ = native.lower_native_graph(expr) + assert second is first + np.testing.assert_array_equal(second.evaluate(arrays), 1) + expr.operands[name] = np.arange(6, dtype=np.float64) + different, _, _ = native.lower_native_graph(expr) + assert different is not first + monkeypatch.setenv("ME_DSL_JIT_COMPILER", "cc") + cc, _, _ = native.lower_native_graph(expr, jit=True) + monkeypatch.setenv("ME_DSL_JIT_COMPILER", "tcc") + tcc, _, _ = native.lower_native_graph(expr, jit=True) + assert tcc is not cc + + +def test_native_text_preparation_errors_are_not_replayed(native_graph_runtime, monkeypatch): + native.compile_plan.cache_clear() + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(6, dtype=np.float32)}) + + def failure(*args, **kwargs): + raise RuntimeError("native text preparation failed") + + def forbidden(*args, **kwargs): + pytest.fail("Unexpected JSON replay after native text preparation failed") + + monkeypatch.setattr(blosc2.NativeGraph, "from_expression", failure) + monkeypatch.setattr(native.GraphAdapter, "visit", forbidden) + with pytest.raises(RuntimeError, match="native text preparation failed"): + native.lower_native_graph(expr) diff --git a/tests/test_native_first.py b/tests/test_native_first.py new file mode 100644 index 000000000..248af297d --- /dev/null +++ b/tests/test_native_first.py @@ -0,0 +1,434 @@ +"""Automatic native selection is conservative and never replays execution.""" + +import numpy as np +import pytest + +import blosc2 +from blosc2.native_graph import prepare_native_first, resident_map_kernel +from conftest import orthogonal_cases + +pytestmark = pytest.mark.skipif(blosc2.IS_WASM, reason="Native graph JIT is unavailable on WASM") + + +@pytest.fixture +def native_first_runtime(native_graph_runtime): + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(4.0)}) + plan = prepare_native_first(expr, ()) + if plan is None or not plan[0].has_jit: + pytest.skip("Automatic native execution requires an available graph JIT") + # These tests qualify the JIT route explicitly; automatic expression policy + # is covered separately and now selects interpretation. + with blosc2.jit_options(jit=True): + yield + + +@pytest.mark.parametrize("dtype", ["int8", "uint64", "float32", "float64", "bool"]) +@pytest.mark.parametrize("safe", [False, True]) +def test_native_first_arithmetic(dtype, safe, native_first_runtime, monkeypatch): + x = np.arange(6).reshape(2, 3).astype(dtype) + y = np.ones((1, 3), dtype=dtype) + expression = "x == y" if dtype == "bool" else "x + (y - 1)" + expr = blosc2.lazyexpr(expression, {"x": x, "y": y}, evaluation="safe" if safe else "full") + + def forbidden(*args, **kwargs): + pytest.fail("Eligible expression used legacy execution") + + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + expected = x == y if dtype == "bool" else x + (y - 1) + np.testing.assert_array_equal(expr[:], expected) + assert expr._native_execution_report["backend"] == "portable-jit" + np.testing.assert_array_equal(expr.compute()[:], expected) + x[:] = 0 + expected = x == y if dtype == "bool" else x + (y - 1) + np.testing.assert_array_equal(expr[:], expected) + + +def test_native_first_borrows_validated_portable_map(native_first_runtime, monkeypatch): + monkeypatch.setenv("ME_DSL_JIT_COMPILER", "tcc") + x = np.arange(300_000, dtype=np.float64) + y = x + 1 + expr = blosc2.lazyexpr("x + (y - 1)", {"x": x, "y": y}) + prepared = prepare_native_first(expr, (slice(None),), jit=True, options={"_getitem": True}) + assert prepared is not None + + def forbidden(*args, **kwargs): + pytest.fail("Prepared graph map was exported and reimported") + + monkeypatch.setattr(blosc2.PortableKernel, "from_json", forbidden) + kernel = resident_map_kernel(prepared[0]) + assert kernel.has_jit + assert kernel.to_json() == prepared[0].map_json() + np.testing.assert_array_equal(kernel.evaluate_block(prepared[1]), x + (y - 1)) + + np.testing.assert_array_equal(expr[:], x + (y - 1)) + assert expr._native_execution_report["route"] == "parallel-resident" + assert expr._native_execution_report["backend"] == "portable-jit" + + +@pytest.mark.parametrize("expression", ["x[1:3]", "sum(sum(x))", "x and y", "unknown(x)"]) +def test_native_first_excluded_syntax(expression): + from blosc2.native_graph import _native_first_syntax + + assert not _native_first_syntax(expression) + + +@pytest.mark.parametrize("kind", ["compressed", "float16", "complex", "empty", "non_native"]) +def test_native_first_excluded_inputs(kind): + x = np.arange(4.0) + if kind == "compressed": + x = blosc2.asarray(x) + elif kind == "float16": + x = x.astype("float16") + elif kind == "complex": + x = x.astype("complex128") + elif kind == "empty": + x = x[:0] + else: + x = x.astype(x.dtype.newbyteorder("S")) + expr = blosc2.lazyexpr("x + 1", {"x": x}) + assert prepare_native_first(expr, ()) is None + + +@pytest.mark.parametrize("item", [slice(0, 0), slice(1, 3), 0, [0, 2], (Ellipsis,)]) +def test_native_first_partial_selection_stays_legacy(item): + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(4.0)}) + assert prepare_native_first(expr, item) is None + + +@pytest.mark.parametrize("options", [{"out": None}, {"_reduce_args": {"op_str": "sum"}}, {"chunks": (2,)}]) +def test_native_first_excluded_options(options): + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(4.0)}) + assert prepare_native_first(expr, (), options=options) is None + + +def test_native_first_explicit_opt_out(native_graph_runtime, monkeypatch): + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(4.0)}) + import blosc2.native_graph as native + + def forbidden(*args, **kwargs): + pytest.fail("Explicit opt-out attempted native preparation") + + monkeypatch.setattr(native, "prepare_native_first", forbidden) + np.testing.assert_array_equal(expr.compute(_require_native=False)[:], np.arange(4.0) + 1) + + +def test_native_first_unavailable_runtime_falls_back(monkeypatch): + import blosc2.native_graph as native + + def unavailable(*args, **kwargs): + raise NotImplementedError("Old dependency") + + monkeypatch.setattr(native, "lower_native_graph", unavailable) + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(4.0)}) + np.testing.assert_array_equal(expr[:], np.arange(4.0) + 1) + with pytest.raises(NotImplementedError, match="Old dependency"): + expr.compute(_require_native=True) + + +def test_native_first_execution_failure_is_not_replayed(native_first_runtime, monkeypatch): + import blosc2.native_graph as native + + def failure(*args, **kwargs): + raise FloatingPointError("Invocation failed") + + def forbidden(*args, **kwargs): + pytest.fail("Native execution failure was replayed") + + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(4.0)}) + monkeypatch.setattr(native, "execute_resident", failure) + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + with pytest.raises(FloatingPointError, match="Invocation failed"): + expr[:] + + +@pytest.mark.parametrize("status", ["invalid_signature", "unsupported"]) +def test_native_first_unsupported_preparation_falls_back(status, monkeypatch): + import blosc2.native_graph as native + + def unsupported(*args, **kwargs): + raise blosc2.PortableArtifactError("Not supported", status=status) + + monkeypatch.setattr(native, "lower_native_graph", unsupported) + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(4.0)}) + np.testing.assert_array_equal(expr[:], np.arange(4.0) + 1) + + +def test_native_first_unexpected_preparation_error_propagates(monkeypatch): + import blosc2.native_graph as native + + def failure(*args, **kwargs): + raise blosc2.PortableArtifactError("Out of memory", status="out_of_memory") + + monkeypatch.setattr(native, "lower_native_graph", failure) + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(4.0)}) + with pytest.raises(blosc2.PortableArtifactError, match="Out of memory"): + expr.compute() + + +def test_native_first_preserves_backend_policy(monkeypatch): + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(4.0)}) + assert prepare_native_first(expr, (), jit_backend="tcc") is None + assert prepare_native_first(expr, (), fp_accuracy=blosc2.FPAccuracy.HIGH) is None + called = [] + original = blosc2.LazyExpr._compute_expr + + def legacy(self, item, kwargs): + called.append(kwargs["jit_backend"]) + # The assertion is about dispatch, independent of compiler availability. + kwargs.pop("jit_backend") + kwargs.pop("jit", None) + return original(self, item, kwargs) + + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", legacy) + monkeypatch.setenv("BLOSC_ME_JIT", "tcc") + np.testing.assert_array_equal(expr[:], np.arange(4.0) + 1) + assert called == ["tcc"] + + +def test_native_first_empty_slice_and_excess_indices(): + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(4.0).reshape(1, 4)}) + assert expr[:0].shape == (0, 4) + with pytest.raises(IndexError): + expr[:, :, :] + + +def test_native_first_report_cleared_on_opt_out(native_first_runtime): + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(4.0)}) + expr.compute() + assert hasattr(expr, "_native_execution_report") + expr.compute(_require_native=False) + assert not hasattr(expr, "_native_execution_report") + + +@pytest.mark.parametrize( + ("dtype", "expression"), + orthogonal_cases( + ["int16", "int32", "int64", "uint8", "uint16", "uint32"], ["x + 1", "-x", "x * 2", "x < 3", "x & 3"] + ), +) +def test_native_first_numeric_coverage(dtype, expression, native_first_runtime): + x = np.arange(6).astype(dtype) + expr = blosc2.lazyexpr(expression, {"x": x}) + expected = eval(expression, {"x": x}) # fixed test expressions only + np.testing.assert_array_equal(expr[:], expected) + assert expr._native_execution_report["backend"] == "portable-jit" + + +@pytest.mark.parametrize("layout", ["strided", "fortran", "scalar"]) +def test_native_first_layout(layout, native_first_runtime): + x = np.arange(12.0).reshape(3, 4) + if layout == "strided": + x = x[::-1, ::2] + elif layout == "fortran": + x = np.asfortranarray(x) + else: + x = np.array(3.0) + expr = blosc2.lazyexpr("x * 2 + 1", {"x": x}) + # A zero-dimensional expression has no axis to slice. + result = expr.compute() + np.testing.assert_array_equal(result[()], x * 2 + 1) + assert hasattr(expr, "_native_execution_report") + + +def test_native_first_jit_request(native_first_runtime): + x = np.arange(8.0) + expr = blosc2.lazyexpr("x + 1", {"x": x}) + np.testing.assert_array_equal(expr.compute(jit=True)[:], x + 1) + assert expr._native_execution_report["backend"] == "portable-jit" + + +def test_native_first_unavailable_jit_uses_interpreter(native_graph_runtime, monkeypatch): + import blosc2.native_graph as native + + original = native.lower_native_graph + + def interpreted(expr, **kwargs): + return original(expr, jit=False) + + monkeypatch.setattr(native, "lower_native_graph", interpreted) + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(4.0)}) + np.testing.assert_array_equal(expr[:], np.arange(4.0) + 1) + assert expr._native_execution_report["backend"] == "portable-interpreter" + + +def test_native_first_jit_false_uses_interpreter(native_graph_runtime, monkeypatch): + import blosc2.native_graph as native + + original = native.lower_native_graph + calls = [] + + def interpreted(*args, **kwargs): + calls.append(kwargs.get("jit")) + return original(*args, **kwargs) + + monkeypatch.setattr(native, "lower_native_graph", interpreted) + expr = blosc2.lazyexpr("x + 1", {"x": np.arange(4.0)}) + np.testing.assert_array_equal(expr.compute(jit=False)[:], np.arange(4.0) + 1) + assert calls + assert not any(calls) + assert expr._native_execution_report["backend"] == "portable-interpreter" + + +@pytest.mark.parametrize("compressed", [False, True]) +@pytest.mark.parametrize("scoped", [False, True]) +@pytest.mark.parametrize( + "policy", + [{"jit": False}, {"jit_backend": "tcc"}, {"fp_accuracy": blosc2.FPAccuracy.HIGH}], +) +def test_native_first_inherited_policy_retains_legacy(monkeypatch, compressed, scoped, policy): + import blosc2.native_graph as native + + monkeypatch.delenv("BLOSC_ME_JIT", raising=False) + values = np.arange(32.0) + operand = blosc2.asarray(values) if compressed else values + expr = blosc2.lazyexpr("x + 1", {"x": operand}) + + original = native.lower_native_graph + calls = [] + + def record(*args, **kwargs): + calls.append(kwargs.get("jit")) + return original(*args, **kwargs) + + monkeypatch.setattr(native, "lower_native_graph", record) + previous = blosc2.get_jit_options() + try: + if scoped: + with blosc2.jit_options(**policy): + result = expr.compute() + else: + blosc2.set_jit_options(**policy) + result = expr.compute() + np.testing.assert_array_equal(result[:], values + 1) + if policy == {"jit": False} and hasattr(expr, "_native_execution_report"): + assert expr._native_execution_report["backend"] == "portable-interpreter" + elif policy != {"jit": False}: + assert not hasattr(expr, "_native_execution_report") + finally: + blosc2.set_jit_options(**previous) + + +@pytest.mark.parametrize( + ("op", "axis", "keepdims"), + orthogonal_cases(["sum", "prod", "min", "max", "any", "all"], [None, 0, -1, (), (0, 1)], [False, True]), +) +def test_native_first_reductions(op, axis, keepdims, native_first_runtime, monkeypatch): + x = np.arange(1, 7.0).reshape(2, 3) + expr = blosc2.lazyexpr("x + 1", {"x": x}) + + def forbidden(*args, **kwargs): + pytest.fail("Eligible reduction used legacy execution") + + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + result = getattr(expr, op)(axis=axis, keepdims=keepdims) + expected = getattr(np, op)(x + 1, axis=axis, keepdims=keepdims) + np.testing.assert_allclose(result, expected) + assert result.shape == expected.shape + assert result.dtype == expected.dtype + assert expr._native_execution_report["jit_stages"] == 1 + + +@pytest.mark.parametrize("expression", ["sum(x + 1)", "(x + 1).sum(axis=-1, keepdims=True)"]) +def test_native_first_root_reductions(expression, native_first_runtime, monkeypatch): + x = np.arange(6.0).reshape(2, 3) + expr = blosc2.lazyexpr(expression, {"x": x}, evaluation="safe") + expected = expr.compute(_require_native=True) + + def forbidden(*args, **kwargs): + pytest.fail("Root reduction used legacy execution") + + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + np.testing.assert_array_equal(expr.compute(), expected) + assert expr._native_execution_report["jit_stages"] == 1 + + +@pytest.mark.parametrize("dtype", ["float32", "float64", "int32", "uint32"]) +def test_native_first_reduction_dtype_initial(dtype, native_first_runtime): + x = np.arange(6).astype(dtype) + expr = blosc2.lazyexpr("x + x", {"x": x}) + result = expr.sum(dtype="float64", initial=3) + np.testing.assert_array_equal(result, np.sum(x + x, dtype="float64", initial=3)) + assert result.dtype == np.dtype("float64") + assert hasattr(expr, "_native_execution_report") + + +@pytest.mark.parametrize("keepdims", [False, True]) +def test_native_first_parallel_sum_and_opt_out(keepdims, native_first_runtime): + previous = blosc2.set_nthreads(2) + try: + x = np.linspace(0, 1, 4 * 128 * 1024).reshape(4, -1) + expr = blosc2.lazyexpr("x + 1", {"x": x}) + result = expr.sum(keepdims=keepdims) + np.testing.assert_allclose(result, np.sum(x + 1, keepdims=keepdims), rtol=1e-12) + assert expr._native_execution_report["route"] == "parallel-resident-reduction" + assert expr._native_execution_report["threads"] == 2 + serial = expr.sum(keepdims=keepdims, _require_native=True, jit=True) + np.testing.assert_allclose(result, serial, rtol=1e-12) + assert expr._native_execution_report.get("route") != "parallel-resident-reduction" + legacy = expr.sum(keepdims=keepdims, _require_native=False) + np.testing.assert_allclose(result, legacy, rtol=1e-12) + assert not hasattr(expr, "_native_execution_report") + finally: + blosc2.set_nthreads(previous) + + +@pytest.mark.parametrize("case", ["broadcast", "strided", "initial", "axis", "single_thread"]) +def test_native_first_sum_keeps_serial_when_not_parallel_eligible(case, native_first_runtime): + previous = blosc2.set_nthreads(1 if case == "single_thread" else 2) + try: + x = np.ones((4, 128 * 1024)) + if case == "strided": + x = x[:, ::-1] + y = np.ones((1, x.shape[1])) if case == "broadcast" else np.ones_like(x) + expr = blosc2.lazyexpr("x + y", {"x": x, "y": y}) + options = {"initial": 3} if case == "initial" else {"axis": 0} if case == "axis" else {} + result = expr.sum(**options) + np.testing.assert_array_equal(result, np.sum(x + y, **options)) + assert expr._native_execution_report.get("route") != "parallel-resident-reduction" + finally: + blosc2.set_nthreads(previous) + + +def test_native_first_parallel_sum_failure_is_not_replayed(native_first_runtime, monkeypatch): + import blosc2.resident_execution as resident + + class FailedPool: + def submit(self, *args, **kwargs): + from concurrent.futures import Future + + future = Future() + future.set_exception(FloatingPointError("Reduction worker failed")) + return future + + def forbidden(*args, **kwargs): + pytest.fail("Reduction failure was replayed") + + previous = blosc2.set_nthreads(2) + try: + monkeypatch.setattr(resident, "resident_pool", lambda: FailedPool()) + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + expr = blosc2.lazyexpr("x + 1", {"x": np.ones(4 * 128 * 1024)}) + with pytest.raises(FloatingPointError, match="Reduction worker failed"): + expr.sum() + finally: + blosc2.set_nthreads(previous) + + +def test_native_first_parallel_sum_combination_status(native_first_runtime): + previous = blosc2.set_nthreads(2) + try: + x = np.zeros(4 * 128 * 1024) + x[0] = x[x.size // 2] = np.finfo("float64").max * 0.75 + expr = blosc2.lazyexpr("x + 0", {"x": x}) + assert np.isposinf(expr.sum()) + assert expr._native_execution_report["fp_flags"] & 4 + assert expr._native_execution_report["route"] == "parallel-resident-reduction" + finally: + blosc2.set_nthreads(previous) + + +def test_native_first_small_compressed_reduction_stays_legacy(native_first_runtime): + x = blosc2.asarray(np.arange(100.0)) + expr = blosc2.lazyexpr("x + 1", {"x": x}) + assert expr.sum() == 5050 + assert not hasattr(expr, "_native_execution_report") diff --git a/tests/test_native_graph_extrema.py b/tests/test_native_graph_extrema.py new file mode 100644 index 000000000..2327b3986 --- /dev/null +++ b/tests/test_native_graph_extrema.py @@ -0,0 +1,152 @@ +"""Parallel graph extrema retain native NaN, signed-zero and status semantics.""" + +import numpy as np +import pytest + +import blosc2 +from blosc2.native_graph import prepare_native_first + + +@pytest.fixture(autouse=True) +def graph_extrema_runtime(native_graph_runtime, request, monkeypatch): + if blosc2.IS_WASM: + pytest.skip("Parallel graph reductions require threads") + backend = getattr(request.node, "callspec", None) + backend = backend.params.get("backend") if backend is not None else None + if backend is not None: + monkeypatch.setenv("ME_DSL_JIT_COMPILER", backend) + expr = blosc2.lazyexpr("x + 1", {"x": np.ones(4)}) + if prepare_native_first(expr, ()) is None: + pytest.skip("Parallel graph extrema require an available native graph JIT") + + +def _extrema_values(dtype, case, size, first, second): + x = np.linspace(-3, 4, size, dtype=dtype) + if case in ("nan", "snan"): + bits = x.view("uint32" if dtype == "float32" else "uint64") + base = ( + (0x7F800000 if case == "snan" else 0x7FC00000) + if dtype == "float32" + else (0x7FF0000000000000 if case == "snan" else 0x7FF8000000000000) + ) + sign = 0x80000000 if dtype == "float32" else 0x8000000000000000 + bits[first] = base | sign | 0x11 + bits[second] = base | 0x22 + elif case == "zeros": + x.fill(-0.0) + x[second] = 0.0 + elif case == "infinities": + x[first] = -np.inf + x[second] = np.inf + return x + + +@pytest.mark.parametrize("op", ["min", "max"]) +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("backend", ["cc", "tcc"]) +@pytest.mark.parametrize("keepdims", [False, True]) +def test_parallel_resident_extrema(op, dtype, backend, keepdims, monkeypatch): + monkeypatch.setenv("ME_DSL_JIT_COMPILER", backend) + x = np.linspace(-3, 4, 4 * 128 * 1024, dtype=dtype).reshape(4, -1) + y = np.ones_like(x) + expr = blosc2.lazyexpr("x + (y - 1)", {"x": x, "y": y}) + previous = blosc2.set_nthreads(2) + try: + result = getattr(expr, op)(axis=(0, 1), keepdims=keepdims) + expected = getattr(np, op)(x, axis=(0, 1), keepdims=keepdims) + np.testing.assert_array_equal(result, expected) + assert result.shape == expected.shape + assert result.dtype == expected.dtype + assert expr._native_execution_report["route"] == "parallel-resident-reduction" + assert expr._native_execution_report["threads"] == 2 + serial = getattr(expr, op)(axis=(0, 1), keepdims=keepdims, _require_native=True, jit=True) + assert result.tobytes() == serial.tobytes() + assert expr._native_execution_report.get("route") != "parallel-resident-reduction" + finally: + blosc2.set_nthreads(previous) + + +@pytest.mark.parametrize("op", ["min", "max"]) +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("backend", ["cc", "tcc"]) +@pytest.mark.parametrize("case", ["nan", "snan", "zeros", "infinities"]) +def test_parallel_extrema_special_values_match_serial(op, dtype, backend, case, monkeypatch): + monkeypatch.setenv("ME_DSL_JIT_COMPILER", backend) + size = 4 * 128 * 1024 + x = _extrema_values(dtype, case, size, size // 2 - 1, size // 2) + expr = blosc2.lazyexpr("x * 1", {"x": x}) + previous = blosc2.set_nthreads(2) + try: + serial = getattr(expr, op)(_require_native=True, jit=True) + serial_flags = expr._native_execution_report["fp_flags"] + parallel = getattr(expr, op)() + assert expr._native_execution_report["route"] == "parallel-resident-reduction" + assert parallel.tobytes() == serial.tobytes() + assert expr._native_execution_report["fp_flags"] == serial_flags + if case == "zeros": + assert bool(np.signbit(parallel)) == (op == "min") + finally: + blosc2.set_nthreads(previous) + + +@pytest.mark.parametrize("op", ["min", "max"]) +@pytest.mark.parametrize("kind", ["axis", "initial", "strided", "broadcast"]) +def test_parallel_extrema_unsupported_layout_stays_serial(op, kind): + x = np.ones((4, 128 * 1024)) + if kind == "strided": + x = x[:, ::-1] + y = np.ones((1, x.shape[1])) if kind == "broadcast" else np.ones_like(x) + expr = blosc2.lazyexpr("x + y", {"x": x, "y": y}) + options = {"axis": 0} if kind == "axis" else {"initial": -3} if kind == "initial" else {} + result = getattr(expr, op)(**options) + expected = getattr(np, op)(x + y, **options) + np.testing.assert_array_equal(result, expected) + assert expr._native_execution_report.get("route") != "parallel-resident-reduction" + + +@pytest.mark.parametrize("op", ["min", "max"]) +@pytest.mark.parametrize("case", ["finite", "nan", "snan", "zeros", "infinities"]) +@pytest.mark.parametrize( + ("dtype", "backend", "root_expression"), + [("float32", "cc", False), ("float64", "tcc", True)], +) +def test_parallel_compressed_extrema(op, dtype, backend, root_expression, case, monkeypatch): + import blosc2.native_graph as native + from blosc2.storage_readers import StorageReader + + if not getattr(blosc2.blosc2_ext, "native_graph_sources_available", lambda: False)(): + pytest.skip("Installed extension does not implement graph storage readers") + monkeypatch.setattr(native, "MINIMUM_COMPRESSED_GRAPH_ITEMS", 4 * 128 * 1024) + monkeypatch.setenv("ME_DSL_JIT_COMPILER", backend) + # Special values in separate chunk regions exercise ordered partial + # combination through native readers, including a ragged final chunk. + values = _extrema_values(dtype, case, 4 * 128 * 1024 + 7, 200_000, 400_000) + x = blosc2.asarray(values, chunks=(128 * 1024,), blocks=(8192,)) + expression = f"{op}(x * 1)" if root_expression else "x * 1" + expr = blosc2.lazyexpr(expression, {"x": x}) + previous = blosc2.set_nthreads(2) + try: + serial = ( + expr.compute(_require_native=True, jit=True) + if root_expression + else getattr(expr, op)(_require_native=True, jit=True) + ) + serial_flags = expr._native_execution_report["fp_flags"] + + def forbidden(*args, **kwargs): + pytest.fail("Parallel compressed extrema used Python/materialization/legacy execution") + + monkeypatch.setattr(blosc2.NDArray, "__getitem__", forbidden) + monkeypatch.setattr(StorageReader, "read", forbidden) + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + result = expr.compute() if root_expression else getattr(expr, op)() + assert result.tobytes() == serial.tobytes() + report = expr._native_execution_report + assert report["route"] == "parallel-graph-bounded-readers" + assert report["fp_flags"] == serial_flags + assert report["threads"] == 2 + assert report["input_materialization_bytes"] == 0 + assert report["maximum_reader_items"] <= report["tile_items"] + assert report["reader_bytes"] == values.nbytes + finally: + blosc2.set_nthreads(previous) diff --git a/tests/test_native_graph_maps.py b/tests/test_native_graph_maps.py new file mode 100644 index 000000000..5d49adc80 --- /dev/null +++ b/tests/test_native_graph_maps.py @@ -0,0 +1,332 @@ +"""Compressed maps share native prefilters, with bounded readers for other layouts.""" + +from concurrent.futures import Future +from itertools import pairwise + +import numpy as np +import pytest + +import blosc2 +from conftest import orthogonal_cases + + +@pytest.fixture(autouse=True) +def map_runtime(native_graph_runtime, monkeypatch, request): + import blosc2.native_graph as native + + if blosc2.IS_WASM: + pytest.skip("Parallel maps require threads") + backend = getattr(request.node, "callspec", None) + if backend is not None and "backend" in backend.params: + monkeypatch.setenv("ME_DSL_JIT_COMPILER", backend.params["backend"]) + probe = blosc2.NativeGraph.from_expression("x + 1", {"x": "float64"}, jit=True) + if not probe.has_jit: + pytest.skip("Graph JIT unavailable") + monkeypatch.setattr(native, "MINIMUM_COMPRESSED_GRAPH_ITEMS", 128 * 1024) + previous = blosc2.set_nthreads(2) + yield + blosc2.set_nthreads(previous) + + +@pytest.mark.parametrize( + ("backend", "dtype", "mixed", "comparison"), + orthogonal_cases(["tcc", "cc"], ["float32", "float64", "int32", "uint32"], [False, True], [False, True]), +) +def test_parallel_compressed_map(backend, dtype, mixed, comparison, monkeypatch): + size = 4 * 65536 + 17 + values = (np.arange(size) % 251).astype(dtype) + x = blosc2.asarray(values, chunks=(65536,), blocks=(4096,)) + y = values if mixed else blosc2.asarray(values, chunks=x.chunks, blocks=x.blocks) + source = "x + (y - 1)" if not comparison else "x > y - 1" + expected = values + (values - 1) if not comparison else values > values - 1 + expression = blosc2.lazyexpr(source, {"x": x, "y": y}) + + def forbidden(*args, **kwargs): + pytest.fail("Graph map must not materialize inputs or invoke Python expression prefilters") + + monkeypatch.setattr(blosc2.NDArray, "__getitem__", forbidden) + monkeypatch.setattr(blosc2.NDArray, "_set_pref_expr", forbidden) + result = expression[:] + np.testing.assert_array_equal(result, expected) + report = expression._native_execution_report + assert report["route"] == "portable-prefilter" + assert report["threads"] == 2 + assert report["native_decoder_contexts"] == (2 if mixed else 4) + assert report["reader_bytes"] == values.nbytes * (1 if mixed else 2) + assert report["maximum_reader_items"] <= report["tile_items"] + # Prefilter scratch contains only compressed input values, even when the + # final output is Boolean; resident operands are borrowed without copying. + assert report["input_buffer_bytes"] == ( + report["tile_items"] * report["threads"] * (1 if mixed else 2) * values.itemsize + ) + assert report["temporary_bytes"] <= 32 * 1024**2 + assert report["output_copy_bytes"] == report["output_zero_fill_bytes"] == 0 + again = blosc2.evaluate(source, local_dict={"x": x, "y": y}) + assert again is not result + np.testing.assert_array_equal(again, expected) + + +def test_parallel_map_persisted_sources(tmp_path): + values = np.arange(4 * 65536 + 1, dtype=np.float64) + x = blosc2.asarray(values, chunks=(65536,), blocks=(8192,), urlpath=str(tmp_path / "x.b2nd")) + expression = blosc2.lazyexpr("x + 1", {"x": x}) + np.testing.assert_array_equal(expression[:], values + 1) + assert expression._native_execution_report["route"] == "parallel-graph-bounded-map" + + +@pytest.mark.parametrize("mixed", [False, True]) +def test_integer_prefilter_avoids_gather_indices(monkeypatch, mixed): + monkeypatch.setattr("blosc2.storage_readers.DENSE_MATERIALIZATION_BUDGET", 2048) + monkeypatch.setattr("blosc2.resident_execution.MINIMUM_WORKER_ITEMS", 64) + monkeypatch.setattr("blosc2.native_graph.MINIMUM_COMPRESSED_GRAPH_ITEMS", 1) + values = np.arange(1027, dtype="int16") + np.int16(32000) + x = blosc2.asarray(values, chunks=(256,), blocks=(64,)) + y = values if mixed else blosc2.asarray(values, chunks=x.chunks, blocks=x.blocks) + expr = blosc2.lazyexpr("x + (y - 1)", {"x": x, "y": y}) + + def forbidden(*args, **kwargs): + pytest.fail("Chunk map used a gather schedule or materialized compressed inputs") + + monkeypatch.setattr(blosc2.NDArray, "__getitem__", forbidden) + monkeypatch.setattr("blosc2.native_graph._compressed_map_schedules", forbidden) + expected = values + (values - 1) + np.testing.assert_array_equal(expr[:], expected) + output = np.empty_like(values) + assert blosc2.evaluate("x + (y - 1)", local_dict={"x": x, "y": y}, out=output) is output + np.testing.assert_array_equal(output, expected) + report = expr._native_execution_report + assert report["route"] == "portable-prefilter" + assert report["gathered_bytes"] == report["output_copy_bytes"] == 0 + assert report["temporary_bytes"] <= 2048 + assert report["evaluated_tiles"] == 4 * (256 // report["tile_items"]) + 1 + assert report["reader_bytes"] == values.nbytes * (1 if mixed else 2) + + +def test_prefilter_workers_join_failures(monkeypatch): + from types import SimpleNamespace + + from blosc2.storage_readers import evaluate_prefilter_numpy + + values = np.arange(4099, dtype="int16") + x = blosc2.asarray(values, chunks=(256,), blocks=(64,)) + author = blosc2.DSLKernel.from_source("def k(x):\n return x + 1\n") + native = blosc2.PortableKernel.from_json(author.export({"x": "int16"}, "int16"), jit=True) + output = np.empty_like(values) + completed = [] + + def execute(inputs, *, numpy_out, _chunk_range, _driver_input, _block_items): + if _chunk_range[0] == 0: + raise OSError("decoder failure") + result = native._handle.evaluate_prefilter( + inputs, + numpy_out=numpy_out, + _chunk_range=_chunk_range, + _driver_input=_driver_input, + _block_items=_block_items, + ) + completed.append(_chunk_range) + return result + + fake = SimpleNamespace( + output_dtype=native.output_dtype, _handle=SimpleNamespace(evaluate_prefilter=execute) + ) + with pytest.raises(OSError, match="decoder failure"): + evaluate_prefilter_numpy(fake, {"x": x}, out=output, workers=2) + # The second worker finishes before the first worker's error escapes. + assert completed == [(8, 17)] + np.testing.assert_array_equal(output[8 * 256 :], (values + 1)[8 * 256 :]) + result, _ = evaluate_prefilter_numpy(native, {"x": x}, workers=2) + np.testing.assert_array_equal(result, values + 1) + + +def test_integer_prefilter_keeps_wide_inputs_parallel(monkeypatch): + monkeypatch.setattr("blosc2.storage_readers.DENSE_MATERIALIZATION_BUDGET", 4608) + monkeypatch.setattr("blosc2.resident_execution.MINIMUM_WORKER_ITEMS", 64) + monkeypatch.setattr("blosc2.native_graph.MINIMUM_COMPRESSED_GRAPH_ITEMS", 1) + bounds = np.iinfo("int64") + values = np.resize(np.array([bounds.min, bounds.max, 0, 1], dtype="int64"), 1027) + x = blosc2.asarray(values, chunks=(256,), blocks=(64,)) + y = blosc2.asarray(values, chunks=x.chunks, blocks=x.blocks) + expr = blosc2.lazyexpr("x + (y - 1)", {"x": x, "y": y}) + + def forbidden(*args, **kwargs): + pytest.fail("Wide-input map fell back instead of reducing its scratch batch size") + + monkeypatch.setattr("blosc2.native_graph._compressed_map_schedules", forbidden) + np.testing.assert_array_equal(expr[:], values + (values - 1)) + report = expr._native_execution_report + assert report["route"] == "portable-prefilter" + assert report["threads"] == 2 + assert report["tile_items"] == 64 + assert report["temporary_bytes"] <= 4608 + assert report["evaluated_tiles"] == 17 + + +def test_parallel_map_padded_chunk_layout(): + values = np.arange(4 * 65536 + 19, dtype=np.float64) + x = blosc2.asarray(values, chunks=(60000,), blocks=(4096,)) + expression = blosc2.lazyexpr("x + 1", {"x": x}) + np.testing.assert_array_equal(expression[:], values + 1) + assert expression._native_execution_report["route"] == "parallel-graph-bounded-map" + + +def test_parallel_map_keeps_compressed_compute_and_serial_fallback(): + values = np.arange(4 * 65536, dtype=np.float64) + x = blosc2.asarray(values, chunks=(65536,), blocks=(4096,)) + expression = blosc2.lazyexpr("x + 1", {"x": x}) + result = expression.compute() + assert isinstance(result, blosc2.NDArray) + np.testing.assert_array_equal(result[:], values + 1) + blosc2.set_nthreads(1) + np.testing.assert_array_equal(expression[:], values + 1) + assert not hasattr(expression, "_native_execution_report") + + +def test_parallel_map_aggregates_late_floating_status(): + values = np.ones(4 * 65536, dtype=np.float64) + values[-1] = 1e308 + x = blosc2.asarray(values, chunks=(65536,), blocks=(4096,)) + expression = blosc2.lazyexpr("x * x", {"x": x}) + result = expression[:] + assert np.isinf(result[-1]) + np.testing.assert_array_equal(result[:-1], 1) + assert expression._native_execution_report["fp_flags"] != 0 + + +def test_parallel_map_python_postfilter(): + values = np.arange(4 * 65536, dtype=np.int32) + x = blosc2.asarray(values, chunks=(65536,), blocks=(4096,)) + x.schunk.dparams = blosc2.DParams(nthreads=1) + + @x.schunk.postfilter(np.int32, np.int32) + def add_offset(input, output, offset): + output[:] = input + 10 + + expression = blosc2.lazyexpr("x + 1", {"x": x}) + np.testing.assert_array_equal(expression[:], values + 11) + assert expression._native_execution_report["route"] == "parallel-graph-bounded-map" + + +def test_parallel_map_worker_failure_is_not_replayed(monkeypatch): + import blosc2.resident_execution as resident + + submissions = [] + + class FailedPool: + def submit(self, *args, **kwargs): + submissions.append(kwargs["_chunk_range"]) + result = Future() + result.set_exception(OSError("map worker failed")) + return result + + def forbidden(*args, **kwargs): + pytest.fail("Failed graph execution was replayed") + + x = blosc2.asarray(np.ones(4 * 65536), chunks=(65536,), blocks=(4096,)) + monkeypatch.setattr(resident, "resident_pool", lambda: FailedPool()) + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + with pytest.raises(OSError, match="map worker failed"): + blosc2.lazyexpr("x + 1", {"x": x})[:] + assert len(submissions) == 2 + assert submissions == [(0, 2), (2, 4)] + + +def test_graph_sources_explicit_output_validation(): + values = np.arange(16, dtype=np.float64) + plan = blosc2.NativeGraph.from_expression("x + 1", {"x": "float64"}, jit=True) + schedule = plan.specialize({"x": (values.dtype, values.shape)}) + out = np.empty_like(values) + result, _ = schedule.execute_sources({"x": values}, {}, out=out) + assert result is out + np.testing.assert_array_equal(out, values + 1) + strided = np.empty(32)[::2] + if getattr(blosc2.blosc2_ext, "native_graph_output_available", lambda: False)(): + result, _ = schedule.execute_sources({"x": values}, {}, out=strided) + assert result is strided + np.testing.assert_array_equal(result, values + 1) + else: + with pytest.raises(ValueError): + schedule.execute_sources({"x": values}, {}, out=strided) + for invalid in (np.empty(15), np.empty(16, dtype=np.float32)): + with pytest.raises(ValueError): + schedule.execute_sources({"x": values}, {}, out=invalid) + out.flags.writeable = False + with pytest.raises(ValueError, match="writable"): + schedule.execute_sources({"x": values}, {}, out=out) + with pytest.raises(ValueError, match="overlap"): + schedule.execute_sources({"x": values}, {}, out=values) + + +@pytest.mark.parametrize("dtype", ["float32", "float64", "int32"]) +@pytest.mark.parametrize("threads", [4, 8, 12]) +@pytest.mark.parametrize("size", [1_000_000, 2_000_000]) +def test_map_crossover_policy(dtype, threads, size, monkeypatch): + import blosc2.native_graph as native + + # Restore production limits rather than the fixture's small test threshold. + monkeypatch.setattr(native, "MINIMUM_COMPRESSED_GRAPH_ITEMS", 16_000_000) + monkeypatch.setattr(native, "MINIMUM_COMPRESSED_MAP_ITEMS", 2_000_000) + blosc2.set_nthreads(threads) + values = np.arange(size, dtype=dtype) + x = blosc2.asarray(values, chunks=(size,), blocks=(15625,)) + expr = blosc2.lazyexpr("x + 1", {"x": x}) + prepared = native.prepare_native_first(expr, (), options={"_getitem": True}) + eligible = dtype in ("float64", "int32") and threads >= 8 and size >= 2_000_000 + assert (prepared is not None) == eligible + if eligible: + result = expr[:] + np.testing.assert_array_equal(result, values + 1) + assert expr._native_execution_report["threads"] > x.schunk.nchunks + assert expr._native_execution_report["tile_items"] == x.blocks[0] + # Reductions keep their old floor even for the new map crossover. + assert native.prepare_native_first(blosc2.lazyexpr("sum(x + 1)", {"x": x}), ()) is None + + +def test_map_schedules_are_immutable_and_operand_free(tmp_path): + import gc + import weakref + + import blosc2.native_graph as native + + native._compressed_map_schedules.cache_clear() + values = np.arange(4 * 65536, dtype=np.float64) + x = blosc2.asarray(values, chunks=(4 * 65536,), blocks=(4096,), urlpath=str(tmp_path / "source.b2nd")) + reference = weakref.ref(x) + # Immutable gather schedules remain the fallback for persisted operands. + expr = blosc2.lazyexpr("x + y", {"x": x, "y": np.ones_like(values)}) + np.testing.assert_array_equal(expr[:], values + 1) + hits = native._compressed_map_schedules.cache_info().hits + np.testing.assert_array_equal(expr[:], values + 1) + assert native._compressed_map_schedules.cache_info().hits > hits + del x, expr + gc.collect() + assert reference() is None + + +def test_balanced_regions_split_physical_blocks_with_tail_padding(): + import blosc2.native_graph as native + + values = np.arange(4 * 65536 + 1, dtype=np.float64) + x = blosc2.asarray(values, chunks=(60000,), blocks=(4096,)) + plan = blosc2.NativeGraph.from_expression("x + 1", {"x": "float64"}, jit=True) + units = native._compressed_map_blocks(x, values.size) + regions = native._compressed_map_schedules(plan, values.shape, 8, 60000, 4096, units, 4096) + assert regions[0][0] == 0 + assert regions[-1][1] == values.size + for start, stop, _ in regions: + assert start < stop + assert start % 60000 % 4096 == 0 + assert all(left[1] == right[0] for left, right in pairwise(regions)) + + +@pytest.mark.parametrize("padded", [False, True]) +def test_map_groups_tiny_blocks_to_amortize_dispatch(padded): + values = np.arange(4 * 65536, dtype=np.float64) + # Padded chunk grids retain bounded readers rather than the prefilter. + x = blosc2.asarray(values, chunks=(60000 if padded else 65536,), blocks=(128,)) + expr = blosc2.lazyexpr("x + 1", {"x": x}) + np.testing.assert_array_equal(expr[:], values + 1) + assert expr._native_execution_report["tile_items"] == 4096 + assert expr._native_execution_report["route"] == ( + "parallel-graph-bounded-map" if padded else "portable-prefilter" + ) diff --git a/tests/test_native_graph_output.py b/tests/test_native_graph_output.py new file mode 100644 index 000000000..36e691034 --- /dev/null +++ b/tests/test_native_graph_output.py @@ -0,0 +1,240 @@ +"""Bindings/dispatch for native descriptor outputs; numerical matrices live in miniexpr.""" + +import numpy as np +import pytest + +import blosc2 + +pytestmark = pytest.mark.skipif(blosc2.IS_WASM, reason="Native graph JIT is unavailable on WASM") + + +@pytest.fixture(autouse=True) +def output_runtime(native_graph_runtime): + if not getattr(blosc2.blosc2_ext, "native_graph_output_available", lambda: False)(): + pytest.skip("Requires native destination descriptors") + + +@pytest.mark.parametrize("jit", [False, True]) +@pytest.mark.parametrize("layout", ["F", "reverse", "stepped"]) +def test_native_graph_destination(jit, layout): + x = np.arange(24.0, dtype="float64").reshape(4, 6) + storage = np.full((8, 12), -999.0) + if layout == "F": + output = np.empty(x.shape, order="F") + elif layout == "reverse": + output = storage[6:2:-1, 10:4:-1] + else: + output = storage[::2, ::2] + plan = blosc2.NativeGraph.from_expression("x + 1", {"x": x.dtype}, jit=jit) + schedule = plan.specialize({"x": (x.dtype, x.shape)}, tile_items=7) + result, report = schedule.execute({"x": x}, out=output) + assert result is output + np.testing.assert_array_equal(result, x + 1) + assert report["temporary_bytes"] <= 7 * 8 + if not jit: + assert report["interpreter_stages"] + if layout != "F": + selected = np.zeros(storage.shape, dtype=bool) + if layout == "reverse": + selected[6:2:-1, 10:4:-1] = True + else: + selected[::2, ::2] = True + np.testing.assert_array_equal(storage[~selected], -999) + + +def test_native_graph_strided_reduction_and_staged_final(): + x = np.arange(24.0).reshape(4, 6) + for expression, expected in [("sum(x, axis=1)", x.sum(axis=1)), ("x - sum(x)", x - x.sum())]: + plan = blosc2.NativeGraph.from_expression(expression, {"x": x.dtype}) + schedule = plan.specialize({"x": (x.dtype, x.shape)}) + storage = np.empty(expected.size * 2) + output = storage[::2].reshape(expected.shape) + result, _ = schedule.execute({"x": x}, out=output) + assert result is output + np.testing.assert_array_equal(result, expected) + + +def test_self_overlapping_output_rejected_before_write(): + x = np.ones((2, 3)) + storage = np.full(6, -999.0) + output = np.lib.stride_tricks.as_strided(storage, shape=x.shape, strides=(8, 8)) + plan = blosc2.NativeGraph.from_expression("x + 1", {"x": x.dtype}) + schedule = plan.specialize({"x": (x.dtype, x.shape)}) + with pytest.raises(blosc2.PortableArtifactError): + schedule.execute({"x": x}, out=output) + np.testing.assert_array_equal(storage, -999) + + +@pytest.mark.parametrize("jit", [False, True]) +def test_native_host_executor_partitions_strided_output(jit): + x = np.arange(600_003.0, dtype="float64") + plan = blosc2.NativeGraph.from_expression("x * 2 + 1", {"x": x.dtype}, jit=jit) + assert plan.info()["partitionable"] + schedule = plan.specialize({"x": (x.dtype, x.shape)}, tile_items=4096) + storage = np.full(x.size * 2, -999.0) + output = storage[::-2] + result, report = schedule.execute({"x": x}, out=output, workers=4) + assert result is output + assert report["tasks"] == 4 + np.testing.assert_array_equal(result, x * 2 + 1) + np.testing.assert_array_equal(storage[::2], -999) + + +def test_native_executor_joins_on_submission_failure(monkeypatch): + import blosc2.resident_execution as resident + + monkeypatch.setattr(blosc2.blosc2_ext, "native_graph_executor_available", lambda: False, raising=False) + pool = resident.resident_pool() + futures = [] + + class FailingPool: + def submit(self, *args): + if futures: + raise ArithmeticError("submission failed") + future = pool.submit(*args) + futures.append(future) + return future + + monkeypatch.setattr(resident, "resident_pool", FailingPool) + x = np.arange(600_003.0) + plan = blosc2.NativeGraph.from_expression("x + 1", {"x": x.dtype}) + schedule = plan.specialize({"x": (x.dtype, x.shape)}) + with pytest.raises(ArithmeticError, match="submission failed"): + schedule.execute({"x": x}, workers=4) + assert futures + assert all(future.done() for future in futures) + + +@pytest.mark.parametrize("jit", [False, True]) +def test_native_executor_reuses_schedule_concurrently(monkeypatch, jit): + from concurrent.futures import ThreadPoolExecutor + + available = getattr(blosc2.blosc2_ext, "native_graph_executor_available", lambda: False) + if not available(): + pytest.skip("Requires a native host executor") + + def forbidden(): + pytest.fail("Native tasks entered the Python executor") + + monkeypatch.setattr("blosc2.resident_execution.resident_pool", forbidden) + x = np.arange(600_003.0) + plan = blosc2.NativeGraph.from_expression("x + 1", {"x": x.dtype}, jit=jit) + schedule = plan.specialize({"x": (x.dtype, x.shape)}) + with ThreadPoolExecutor(max_workers=2) as pool: + futures = [ + pool.submit(schedule.execute, {"x": x + offset}, workers=workers) + for offset, workers in ((0, 2), (10, 4)) + ] + for future, (offset, workers) in zip(futures, ((0, 2), (10, 4)), strict=True): + result, report = future.result() + np.testing.assert_array_equal(result, x + offset + 1) + assert report["tasks"] == workers + + +def test_public_disjoint_views_of_same_allocation(): + storage = np.arange(48.0) + x, output = storage[:24], storage[24:] + expected = x + 1 + assert blosc2.evaluate("x + 1", local_dict={"x": x}, out=output) is output + np.testing.assert_array_equal(output, expected) + + +def test_buffer_backed_destination(): + x = np.arange(24.0) + storage = bytearray(24 * 16) + output = np.frombuffer(storage, dtype="float64")[::2] + assert blosc2.evaluate("x + 1", local_dict={"x": x}, out=output) is output + np.testing.assert_array_equal(output, x + 1) + + +def test_disjoint_views_from_same_buffer_owner(): + buffer = bytearray(np.arange(48.0).tobytes()) + x = np.frombuffer(buffer, dtype="float64")[:24] + output = np.frombuffer(buffer, dtype="float64")[24:] + expected = x + 1 + assert blosc2.evaluate("x + 1", local_dict={"x": x}, out=output) is output + np.testing.assert_array_equal(output, expected) + + +def test_public_native_sources_preserve_strided_output(): + x = np.arange(24.0).reshape(4, 6) + stored = blosc2.asarray(x, chunks=(2, 3), blocks=(1, 3)) + output = np.empty(x.shape, order="F") + plan = blosc2.NativeGraph.from_expression("x + 1", {"x": x.dtype}) + result, report = plan.evaluate_sources({"x": stored}, out=output, tile_items=7, return_report=True) + assert result is output + np.testing.assert_array_equal(result, x + 1) + assert report["maximum_reader_items"] <= 7 + assert report["interpreter_stages"] == 1 + + +@pytest.mark.parametrize("layout", ["C", "F", "reverse", "stepped"]) +def test_native_identity_copy_without_interpreter_or_jit(layout): + x = np.arange(24.0).reshape(4, 6) + if layout == "F": + x = np.asfortranarray(x) + output = np.empty_like(x, order="F") + elif layout == "reverse": + x = x[::-1, ::-1] + output = np.empty((4, 6))[::-1, ::-1] + elif layout == "stepped": + output = np.empty((8, 12))[::2, ::2] + else: + output = np.empty_like(x) + plan = blosc2.NativeGraph.from_expression("x", {"x": x.dtype}) + result, report = plan.evaluate({"x": x}, out=output, return_report=True) + assert result is output + np.testing.assert_array_equal(result, x) + assert report["evaluated_tiles"] == 0 + + +@pytest.mark.parametrize("jit", [False, True]) +def test_matching_fortran_maps_avoid_gather_and_scatter(jit): + x = np.asfortranarray(np.arange(24.0).reshape(4, 6)) + y = np.asfortranarray(x + 2) + output = np.empty(x.shape, order="F") + plan = blosc2.NativeGraph.from_expression("x + y", {"x": x.dtype, "y": y.dtype}, jit=jit) + result, report = plan.evaluate({"x": x, "y": y}, out=output, return_report=True) + assert result is output + np.testing.assert_array_equal(result, x + y) + assert report["temporary_bytes"] == 0 + assert report["gathered_bytes"] == 0 + + +def test_native_final_conversion_into_fortran_output(): + import json + + x = np.arange(24.0).reshape(4, 6) + base = blosc2.NativeGraph.from_expression("x + 1", {"x": x.dtype}) + graph = json.loads(base.to_json()) + graph["output"]["dtype"] = "float32" + plan = blosc2.NativeGraph(graph) + output = np.empty(x.shape, dtype="float32", order="F") + result = plan.evaluate({"x": x}, out=output) + assert result is output + np.testing.assert_array_equal(result, (x + 1).astype("float32")) + + +def test_native_staged_final_conversion_into_fortran_output(): + x = np.arange(24.0).reshape(4, 6) + # Staged regions express conversion as an explicit cast node, not a final + # output-dtype override; preserve the native format's established contract. + plan = blosc2.NativeGraph.from_expression("float32(x - sum(x))", {"x": x.dtype}) + output = np.empty(x.shape, dtype="float32", order="F") + result = plan.evaluate({"x": x}, out=output) + assert result is output + np.testing.assert_array_equal(result, (x - x.sum()).astype("float32")) + + +@pytest.mark.parametrize( + "expression", + ["sin(x) + cos(x)", "sqrt(x * x)", "x / (x + 1)", "where(x > 0.5, x + 1, x - 1)", "fmod(x, x + 0.1)"], +) +def test_promoted_integer_math_is_native_partitionable(expression): + x = np.arange(1, 600_004, dtype="int64") % 97 + plan = blosc2.NativeGraph.from_expression(expression, {"x": x.dtype}, jit=True) + assert plan.info()["partitionable"] + expected = plan.evaluate({"x": x}) + result, report = plan.evaluate({"x": x}, workers=4, return_report=True) + np.testing.assert_array_equal(result, expected) + assert report["tasks"] == 4 diff --git a/tests/test_native_graph_preparation.py b/tests/test_native_graph_preparation.py new file mode 100644 index 000000000..20c4bf21b --- /dev/null +++ b/tests/test_native_graph_preparation.py @@ -0,0 +1,715 @@ +"""Native semantic preparation, independent of Python's numerical planner.""" + +import json +import sys +from concurrent.futures import ThreadPoolExecutor + +import numpy as np +import pytest +from blosc2.blosc2_ext import NativeGraphHandle + +import blosc2 +from blosc2.native_graph import lower_native_graph, scalar_descriptor +from conftest import orthogonal_cases + +pytestmark = pytest.mark.usefixtures("native_graph_runtime") + + +@pytest.mark.parametrize( + ("dtype", "op", "tile"), + orthogonal_cases( + ["float32", "float64", "int32", "int64"], ["sum", "prod", "min", "max", "any", "all"], [1, 5, 64] + ), +) +def test_direct_input_reduction_bypasses_map(dtype, op, tile): + x = np.arange(1, 13, dtype=dtype).reshape(3, 4) + plan = blosc2.NativeGraph.from_expression(f"{op}(x, axis=-1)", {"x": dtype}, jit=True) + actual, report = plan.evaluate({"x": x}, tile_items=tile, return_report=True) + np.testing.assert_array_equal(actual, getattr(np, op)(x, axis=-1)) + assert report["evaluated_tiles"] == 0 + assert report["temporary_bytes"] == 0 + assert report["jit_stages"] == 0 + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +def test_direct_sum_order_status_initial_and_fallback(dtype): + large = 2 ** (24 if dtype == "float32" else 53) + plan = blosc2.NativeGraph.from_expression("sum(x, initial=2)", {"x": dtype}) + x = np.array([large, 1, -large, 3], dtype=dtype) + # Serial accumulation includes initial before the first input, not after + # a tile partial sum. Compute the expected rounding step by step. + expected = np.dtype(dtype).type(2) + for value in x: + expected = np.dtype(dtype).type(expected + value) + for tile in (1, 3, 64): + actual, report = plan.evaluate({"x": x}, tile_items=tile, return_report=True) + assert actual == expected + assert report["evaluated_tiles"] == 0 + for values, flags in (([np.finfo(dtype).max, np.finfo(dtype).max], 4), ([np.inf, -np.inf], 1)): + _, report = plan.evaluate({"x": np.array(values, dtype=dtype)}, return_report=True) + assert report["fp_flags"] == (0 if sys.platform == "emscripten" else flags) + reverse = x[::-1] + actual, report = plan.evaluate({"x": reverse}, return_report=True) + expected = np.dtype(dtype).type(2) + for value in reverse: + expected = np.dtype(dtype).type(expected + value) + assert actual == expected + assert report["evaluated_tiles"] > 0 + assert report["gathered_bytes"] > 0 + + +@pytest.mark.parametrize( + ("dtype", "op", "tile"), + orthogonal_cases( + ["float32", "float64", "int8", "int64", "uint64"], + ["sum", "prod", "min", "max", "any", "all"], + [1, 3, 64], + ), +) +def test_computed_reduction_typed_matches_masked_generic(dtype, op, tile): + x = np.array([1, 2, 0, 3, 1, 2], dtype=dtype) + initial = ", initial=0" if op in ("min", "max") else "" + expression = f"{op}(x + zero{initial})" + inputs = {"x": x, "zero": np.zeros_like(x)} + plan = blosc2.NativeGraph.from_expression( + expression, {name: value.dtype for name, value in inputs.items()} + ) + actual, report = plan.evaluate(inputs, tile_items=tile, return_report=True) + inputs["mask"] = np.ones(x.shape, dtype=bool) + generic = blosc2.NativeGraph.from_expression( + f"{op}(x + zero, where=mask{initial})", {name: value.dtype for name, value in inputs.items()} + ) + expected, reference = generic.evaluate(inputs, tile_items=tile, return_report=True) + assert actual.dtype == expected.dtype + assert actual.tobytes() == expected.tobytes() + assert report["fp_flags"] == reference["fp_flags"] + assert report["evaluated_tiles"] > 0 + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize( + ("op", "case"), + [ + ("sum", "cancellation"), + ("sum", "overflow"), + ("sum", "snan"), + ("prod", "overflow"), + ("prod", "underflow"), + ("min", "nan"), + ("max", "nan"), + ("min", "snan"), + ("max", "snan"), + ("min", "signed_zero"), + ("max", "signed_zero"), + ("any", "nan"), + ("all", "signed_zero"), + ], +) +def test_computed_reduction_float_edge_parity(dtype, op, case): + large = 2 ** (24 if dtype == "float32" else 53) + values = { + "cancellation": [large, 1, -large, 3], + "nan": [1, np.nan, 2, -np.nan], + "snan": [1, 2], + "overflow": [np.finfo(dtype).max, np.finfo(dtype).max], + "underflow": [np.finfo(dtype).tiny, np.finfo(dtype).tiny], + "signed_zero": [-0.0, 0.0, -0.0], + } + x = np.array(values[case], dtype=dtype) + if case == "snan": + x.view("uint32" if dtype == "float32" else "uint64")[1] = ( + 0x7F800001 if dtype == "float32" else 0x7FF0000000000001 + ) + initial = ", initial=0" if op in ("min", "max") else "" + inputs = {"x": x, "one": np.ones_like(x)} + plan = blosc2.NativeGraph.from_expression( + f"{op}(x * one{initial})", {name: value.dtype for name, value in inputs.items()} + ) + masked_inputs = {**inputs, "mask": np.ones(x.shape, dtype=bool)} + generic = blosc2.NativeGraph.from_expression( + f"{op}(x * one, where=mask{initial})", {name: value.dtype for name, value in masked_inputs.items()} + ) + for tile in (1, 3, 64): + actual, report = plan.evaluate(inputs, tile_items=tile, return_report=True) + expected, reference = generic.evaluate(masked_inputs, tile_items=tile, return_report=True) + assert actual.dtype == expected.dtype + # Portable arithmetic does not specify NaN payload/sign. Preserve exact + # bits for all other results, especially signed-zero selection. + if np.isnan(expected).all(): + assert np.isnan(actual).all() + else: + assert actual.tobytes() == expected.tobytes() + assert report["fp_flags"] == reference["fp_flags"] + + +def make_portable_sum(dtype, body="return block_sum(x)", cardinality="block_scalar", *, output_dtype=None): + artifact = blosc2.DSLKernel.from_source(f"def k(x):\n {body}\n").export( + {"x": dtype}, output_dtype or dtype, version="1.0", cardinality=cardinality + ) + return blosc2.PortableKernel.from_json(artifact, jit=False) + + +@pytest.mark.parametrize( + ("dtype", "op"), + orthogonal_cases( + [ + "bool", + "int8", + "int16", + "int32", + "int64", + "uint8", + "uint16", + "uint32", + "uint64", + "float32", + "float64", + ], + ["prod", "min", "max", "any", "all"], + ), +) +def test_typed_reductions_match_generic(dtype, op): + x = np.array([1, 2, 0, 3, 1, 2], dtype=dtype) + output_dtype = ( + "bool" + if op in ("any", "all") + else ("uint64" if dtype.startswith("uint") else "int64") + if op == "prod" and dtype not in ("float32", "float64") + else dtype + ) + kernel = make_portable_sum(dtype, f"return block_{op}(x)", output_dtype=output_dtype) + actual, status = kernel.evaluate_block({"x": x}, return_status=True) + # A partial mask forces the original reducer, without altering input values. + padded = np.append(x, np.array([0], dtype=dtype)) + mask = np.arange(padded.size) < x.size + expected, reference = kernel.evaluate_block({"x": padded}, valid_mask=mask, return_status=True) + assert actual.tobytes() == expected.tobytes() + assert status == reference + np.testing.assert_array_equal(actual, getattr(np, op)(x)) + plan = blosc2.NativeGraph.from_expression(f"{op}(x)", {"x": dtype}) + strided = np.repeat(x, 2)[::2] + for tile in (1, 4, 64): + actual, report = plan.evaluate({"x": x}, tile_items=tile, return_report=True) + expected, reference = plan.evaluate({"x": strided}, tile_items=tile, return_report=True) + assert actual.tobytes() == expected.tobytes() + assert report["fp_flags"] == reference["fp_flags"] + assert report["evaluated_tiles"] == 0 + assert reference["evaluated_tiles"] > 0 + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize( + ("op", "case"), + [ + ("prod", "overflow"), + ("prod", "underflow"), + ("prod", "invalid"), + ("prod", "empty"), + ("min", "zero"), + ("max", "zero"), + ("min", "nan"), + ("max", "nan"), + ("min", "snan"), + ("max", "snan"), + ("min", "empty"), + ("max", "empty"), + ("any", "snan"), + ("all", "zero"), + ("any", "empty"), + ("all", "empty"), + ], +) +def test_typed_float_reduction_edge_parity(dtype, op, case): + cases = { + "zero": [-0.0, 0.0, -0.0], + "nan": [1, np.nan, 2, -np.nan], + "snan": [1, 2], + "overflow": [np.finfo(dtype).max, 2], + "underflow": [np.finfo(dtype).tiny, np.finfo(dtype).tiny], + "invalid": [np.inf, 0], + "empty": [], + } + x = np.array(cases[case], dtype=dtype) + if case == "snan": + x.view("uint32" if dtype == "float32" else "uint64")[1] = ( + 0x7F800001 if dtype == "float32" else 0x7FF0000000000001 + ) + kernel = make_portable_sum( + dtype, f"return block_{op}(x)", output_dtype="bool" if op in ("any", "all") else dtype + ) + padded = np.append(x, np.array([0], dtype=dtype)) + mask = np.arange(padded.size) < x.size + if not x.size and op in ("min", "max"): + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block({"x": x}) + return + actual, status = kernel.evaluate_block({"x": x}, return_status=True) + expected, reference = kernel.evaluate_block({"x": padded}, valid_mask=mask, return_status=True) + if not (np.isnan(actual).all() and np.isnan(expected).all()): + assert actual.tobytes() == expected.tobytes() + assert status == reference + expression = f"{op}(x, initial=1)" if op in ("min", "max") else f"{op}(x)" + plan = blosc2.NativeGraph.from_expression(expression, {"x": dtype}) + for tile in (1, 3, 64): + actual, report = plan.evaluate({"x": x}, tile_items=tile, return_report=True) + expected, reference = plan.evaluate({"x": np.repeat(x, 2)[::2]}, tile_items=tile, return_report=True) + assert actual.dtype == expected.dtype + assert actual.shape == expected.shape + if not (np.isnan(actual).all() and np.isnan(expected).all()): + assert actual.tobytes() == expected.tobytes() + assert report["fp_flags"] == reference["fp_flags"] + + +@pytest.mark.parametrize( + ("dtype", "values"), + [ + ("int64", [2**63 - 1, 2, 0]), + ("int64", [-(2**63), -1, 0]), + ("uint64", [2**64 - 1, 2, 0]), + ], +) +def test_typed_product_prefix_overflow(dtype, values): + x = np.array(values, dtype=dtype) + kernel = make_portable_sum(dtype, "return block_prod(x)") + for data, mask in ( + (x, None), + (np.append(x, np.array([1], dtype=dtype)), np.array([True, True, True, False])), + ): + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block({"x": data}, valid_mask=mask) + assert kernel.evaluate_block({"x": np.array([2, 3], dtype=dtype)}) == 6 + plan = blosc2.NativeGraph.from_expression("prod(x)", {"x": dtype}) + for tile in (1, 64): + assert plan.evaluate({"x": x}, tile_items=tile) == 0 + + +@pytest.mark.parametrize("dtype", ["int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64"]) +@pytest.mark.parametrize("op", ["min", "max"]) +def test_typed_integer_extrema_bounds(dtype, op): + limits = np.iinfo(dtype) + x = np.array([limits.max, 0, limits.min, 1], dtype=dtype) + kernel = make_portable_sum(dtype, f"return block_{op}(x)") + assert kernel.evaluate_block({"x": x}) == getattr(np, op)(x) + plan = blosc2.NativeGraph.from_expression(f"{op}(x, initial=1)", {"x": dtype}) + for tile in (1, 64): + assert plan.evaluate({"x": x}, tile_items=tile) == getattr(np, op)(x, initial=1) + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("op", ["prod", "min", "max", "any", "all"]) +def test_typed_reductions_initialized_locals_and_masks(dtype, op): + output_dtype = "bool" if op in ("any", "all") else dtype + x = np.array([-2, 0, 3, 4], dtype=dtype) + local = make_portable_sum(dtype, f"y = x\n return block_{op}(y)", output_dtype=output_dtype) + assert local.evaluate_block({"x": x}) == getattr(np, op)(x) + mask = np.array([False, False, True, True]) + assert local.evaluate_block({"x": x}, valid_mask=mask) == getattr(np, op)(x[mask]) + + +@pytest.mark.parametrize("dtype", ["float32", "float64", "int64", "uint64"]) +def test_typed_product_initial_and_conversion_fallback(dtype): + x = np.array([1, 2, 3, 4], dtype=dtype) + plan = blosc2.NativeGraph.from_expression("prod(x, initial=3)", {"x": dtype}) + for tile in (1, 3, 64): + assert plan.evaluate({"x": x}, tile_items=tile) == 72 + accumulator = ("float64" if dtype == "float32" else "float32") if dtype.startswith("float") else "int8" + plan = blosc2.NativeGraph.from_expression(f"prod(x, dtype={accumulator}, initial=3)", {"x": dtype}) + x = np.array([12, 12, 12], dtype=dtype) + result = plan.evaluate({"x": x}) + assert result.dtype == np.dtype(accumulator) + assert result == np.prod(x, dtype=accumulator, initial=3) + + +@pytest.mark.parametrize( + ("dtype", "tile"), + orthogonal_cases( + ["bool", "int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64"], [1, 5, 64] + ), +) +def test_integer_bool_direct_sums(dtype, tile): + output_dtype = "uint64" if dtype.startswith("uint") else "int64" + values = [0, 1, 3, 7, 2, 0, 5] * 3 + if dtype.startswith("int"): + values[2] = -3 + values[3] = -7 + x = np.array(values, dtype=dtype) + direct = make_portable_sum(dtype, output_dtype=output_dtype) + generic = make_portable_sum(dtype, "return block_sum(x + 0)", output_dtype=output_dtype) + graph_plan = blosc2.NativeGraph.from_expression("sum(x)", {"x": dtype}) + expected = np.sum(x, dtype=output_dtype) + for kernel in (direct, generic): + result, status = kernel.evaluate_block({"x": x}, return_status=True) + assert result.dtype == expected.dtype + assert result == expected + assert status["flags"] == 0 + result, report = graph_plan.evaluate({"x": x}, tile_items=tile, return_report=True) + assert result.dtype == expected.dtype + assert result == expected + assert report["evaluated_tiles"] == report["temporary_bytes"] == 0 + mask = np.arange(x.size) % 2 == 0 + for kernel in (direct, generic): + result = kernel.evaluate_block({"x": x}, valid_mask=mask) + assert result == np.sum(x[mask], dtype=output_dtype) + + +@pytest.mark.parametrize( + ("dtype", "values", "expected"), + [ + ("int64", [2**63 - 1, 1], -(2**63)), + ("int64", [-(2**63), -1], 2**63 - 1), + ("uint64", [2**64 - 1, 1], 0), + ], +) +def test_direct_integer_sum_preserves_route_overflow(dtype, values, expected): + x = np.array(values, dtype=dtype) + for body in ("return block_sum(x)", "return block_sum(x + 0)"): + kernel = make_portable_sum(dtype, body) + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block({"x": x}) + # Failure must not poison subsequent use of the same immutable kernel. + assert kernel.evaluate_block({"x": np.array([1, 2], dtype=dtype)}) == 3 + plan = blosc2.NativeGraph.from_expression("sum(x)", {"x": dtype}) + for tile in (1, 64): + assert plan.evaluate({"x": x}, tile_items=tile) == expected + + +def test_direct_integer_sum_initial_and_nondefault_accumulator(): + x = np.array([True], dtype=bool) + plan = blosc2.NativeGraph.from_expression("sum(x, initial=9223372036854775807)", {"x": "bool"}) + assert plan.evaluate({"x": x}) == -(2**63) + x = np.array([120, 120, 120], dtype="int64") + plan = blosc2.NativeGraph.from_expression("sum(x, dtype=int8)", {"x": "int64"}) + actual = plan.evaluate({"x": x}) + assert actual.dtype == np.dtype("int8") + assert actual == np.sum(x, dtype="int8") + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("case", ["order", "overflow", "invalid", "nan", "zero", "empty"]) +def test_dsl_direct_sum_matches_generic(dtype, case): + large = 2 ** (24 if dtype == "float32" else 53) + cases = { + "order": [large, 1, -large, 3], + "overflow": [np.finfo(dtype).max, np.finfo(dtype).max], + "invalid": [np.inf, -np.inf], + "nan": [np.nan, 1, 2], + "zero": [-0.0, -0.0], + "empty": [], + } + x = np.array(cases[case], dtype=dtype) + direct = make_portable_sum(dtype) + # Computed operands still execute the generic expression reduction loop. + generic = make_portable_sum(dtype, "return block_sum(x * 1)") + actual, status = direct.evaluate_block({"x": x}, return_status=True) + expected, reference = generic.evaluate_block({"x": x}, return_status=True) + np.testing.assert_array_equal(actual, expected) + assert actual.tobytes() == expected.tobytes() + assert status == reference + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +def test_dsl_direct_sum_masks_and_initialized_locals(dtype): + direct = make_portable_sum(dtype) + x = np.array([np.inf, -np.inf, 2, 3], dtype=dtype) + actual, status = direct.evaluate_block( + {"x": x}, valid_mask=np.array([False, False, True, True]), return_status=True + ) + assert actual == 5 + assert status["flags"] == 0 + local = make_portable_sum(dtype, "y = x\n return block_sum(y)") + actual = local.evaluate_block({"x": np.array([1, 2, 3], dtype=dtype)}) + assert actual == 6 + branch = make_portable_sum(dtype, "return where(x > 0, block_sum(x), 0)", "elementwise") + actual = branch.evaluate_block({"x": np.array([-1, 2, 3, -4], dtype=dtype)}) + np.testing.assert_array_equal(actual, [0, 5, 5, 0]) + + +def graph(nodes, root=None, output="auto"): + return json.dumps( + { + "format": "menudet-graph-1", + "semantics": "menudet-numpy-1.0", + "requires": ["numeric"], + "nodes": [{"id": i, **node} for i, node in enumerate(nodes)], + "root": len(nodes) - 1 if root is None else root, + "output": {"dtype": output, "casting": "unsafe"}, + } + ).encode() + + +def test_preparation_without_python_semantic_planning(monkeypatch): + x = np.arange(12, dtype="float32").reshape(4, 3) + with blosc2.expression_evaluation("safe"): + expr = blosc2.lazyexpr("x * 2 + y", {"x": x, "y": np.ones((1, 3), dtype="float32")}) + + def forbidden(*args, **kwargs): + pytest.fail("Python semantic planning/source generation was called") + + from blosc2.dsl_kernel import DSLKernel + + monkeypatch.setattr(DSLKernel, "from_source", forbidden) + monkeypatch.setattr(DSLKernel, "export", forbidden) + monkeypatch.setattr(np, "broadcast_shapes", forbidden) + monkeypatch.setattr(np, "result_type", forbidden) + plan, arrays, reduction = lower_native_graph(expr) + assert not reduction + schedule = plan.specialize({name: (value.dtype, value.shape) for name, value in arrays.items()}) + assert schedule.info()["shape"] == (4, 3) + result, _ = schedule.execute(arrays) + np.testing.assert_array_equal(result, x * 2 + 1) + + +@pytest.mark.parametrize( + "value", [np.float32(-0.0), np.float64(np.inf), np.int8(-128), np.uint64(2**64 - 1)] +) +def test_lossless_capture_and_roundtrip(value): + encoded = graph([{"op": "constant", **scalar_descriptor(value)}]) + plan = NativeGraphHandle(encoded) + imported = NativeGraphHandle(plan.to_json().encode()) + schedule = imported.specialize({}) + result, _ = schedule.execute({}) + assert result.dtype == value.dtype + assert result.tobytes() == value.tobytes() + + +def test_weak_typed_and_zero_dimensional_strength(): + signatures = [{"op": "input", "name": "x", "dtype": "float32"}] + weak = NativeGraphHandle( + graph( + signatures + + [ + {"op": "constant", **scalar_descriptor(2.0)}, + {"op": "add", "args": [0, 1]}, + ] + ) + ) + typed = NativeGraphHandle( + graph( + signatures + + [ + {"op": "constant", **scalar_descriptor(np.float64(2))}, + {"op": "add", "args": [0, 1]}, + ] + ) + ) + strong = NativeGraphHandle( + graph( + signatures + + [ + {"op": "input", "name": "scalar", "dtype": "float64"}, + {"op": "add", "args": [0, 1]}, + ] + ) + ) + assert weak.info()["inferred_dtype"] == np.dtype("float32") + assert typed.info()["inferred_dtype"] == strong.info()["inferred_dtype"] == np.dtype("float64") + schedule = strong.specialize({"x": ("float32", (3,)), "scalar": ("float64", ())}) + result, _ = schedule.execute({"x": np.ones(3, dtype="float32"), "scalar": np.array(4.0)}) + np.testing.assert_array_equal(result, [5, 5, 5]) + + +def test_final_conversion_is_not_intermediate_precision(): + plan = NativeGraphHandle( + graph( + [ + {"op": "input", "name": "x", "dtype": "float32"}, + {"op": "constant", **scalar_descriptor(1.0)}, + {"op": "add", "args": [0, 1]}, + {"op": "sub", "args": [2, 0]}, + ], + output="float64", + ) + ) + assert plan.info()["inferred_dtype"] == np.dtype("float32") + schedule = plan.specialize({"x": ("float32", (1,))}) + assert schedule.info()["dtype"] == np.dtype("float64") + result, _ = schedule.execute({"x": np.array([2**24], dtype="float32")}) + assert result[0] == 0 # float32 add rounds before the final float64 cast. + + +def test_schedule_retains_plan_and_concurrent_invocations(): + plan = NativeGraphHandle( + graph( + [ + {"op": "input", "name": "x", "dtype": "int64"}, + {"op": "constant", **scalar_descriptor(2)}, + {"op": "mul", "args": [0, 1]}, + ] + ) + ) + schedule = plan.specialize({"x": ("int64", (100,))}) + del plan + + def run(value): + result, _ = schedule.execute({"x": np.full(100, value, dtype="int64")}) + np.testing.assert_array_equal(result, value * 2) + + if sys.platform == "emscripten": + list(map(run, range(16))) + else: + with ThreadPoolExecutor(max_workers=4) as executor: + list(executor.map(run, range(16))) + + +def test_root_mask_initial_and_recovery(): + plan = NativeGraphHandle( + graph( + [ + {"op": "input", "name": "x", "dtype": "float64"}, + {"op": "function", "name": "sqrt", "args": [0]}, + {"op": "input", "name": "mask", "dtype": "bool"}, + { + "op": "sum", + "args": [1], + "axes": [-1], + "keepdims": True, + "dtype": "auto", + "initial": scalar_descriptor(2), + "where": 2, + }, + ] + ) + ) + schedule = plan.specialize({"x": ("float64", (2, 2)), "mask": ("bool", (2,))}, 1) + x = np.array([[4.0, -1], [9, -1]]) + policy = 0 if sys.platform == "emscripten" else 1 + if sys.platform == "emscripten": + with pytest.raises(blosc2.PortableArtifactError, match="floating status unavailable"): + schedule.execute({"x": x, "mask": np.array([True, False])}, 1) + result, report = schedule.execute({"x": x, "mask": np.array([True, False])}, policy) + np.testing.assert_array_equal(result, [[4], [5]]) + assert not report["fp_flags"] + if sys.platform == "emscripten": + result, _ = schedule.execute({"x": x, "mask": np.array([True, True])}, policy) + assert np.isnan(result).all() + else: + with pytest.raises(blosc2.PortableArtifactError, match="floating") as failure: + schedule.execute({"x": x, "mask": np.array([True, True])}, 1) + assert failure.value.fp_status["flags"] & 1 + result, report = schedule.execute({"x": x, "mask": np.array([True, False])}, policy) + np.testing.assert_array_equal(result, [[4], [5]]) + assert not report["fp_flags"] + + +def test_public_plan_and_root_initial_adapter(): + nodes = [{"op": "input", "name": "x", "dtype": "float32"}] + plan = blosc2.NativeGraph.from_json(graph(nodes)) + assert plan.input_dtypes == {"x": np.dtype("float32")} + values = np.arange(6, dtype="float32") + np.testing.assert_array_equal(plan.evaluate({"x": values}), values) + with blosc2.expression_evaluation("safe"): + expr = blosc2.lazyexpr("sum(x)", {"x": values}) + assert expr.compute(_require_native=True, initial=2) == 17 + + +def test_native_text_frontend_and_json_equivalence(): + text = blosc2.NativeGraph.from_expression("where(x != 0, y / x, y)", {"x": "float32", "y": "float32"}) + imported = blosc2.NativeGraph.from_json(text.to_json()) + values = {"x": np.array([0, 2, 4], dtype="float32"), "y": np.array(8, dtype="float32")} + a, report = text.evaluate(values, return_report=True) + b = imported.evaluate(values) + assert a.dtype == b.dtype == np.dtype("float32") + assert a.tobytes() == b.tobytes() + np.testing.assert_array_equal(a, [8, 4, 2]) + assert not report["fp_flags"] + + +def test_explicit_conversion_budget_preflight(): + plan = blosc2.NativeGraph.from_json( + graph([{"op": "input", "name": "x", "dtype": "float32"}], output="float64") + ) + with pytest.raises(blosc2.PortableArtifactError, match="budget"): + plan.specialize({"x": ("float32", (3,))}, intermediate_budget=4) + schedule = plan.specialize({"x": ("float32", (3,))}, intermediate_budget=12) + result, _ = schedule.execute({"x": np.ones(3, dtype="float32")}) + np.testing.assert_array_equal(result, [1, 1, 1]) + + +def test_required_jit_fails_closed(monkeypatch): + monkeypatch.setenv("CFLAGS", "-ffast-math") + with pytest.raises(blosc2.PortableArtifactError, match="JIT"): + blosc2.NativeGraph.from_expression("x + 1", {"x": "float32"}, require_jit=True) + + +@pytest.mark.parametrize("layout", ["c", "f", "reverse", "step", "unaligned", "swapped"]) +def test_native_graph_layouts(layout): + source = np.arange(24, dtype="float64").reshape(4, 6) + if layout == "f": + source = np.asfortranarray(source) + elif layout == "reverse": + source = source[::-1, ::-1] + elif layout == "step": + source = source[:, ::2] + elif layout == "unaligned": + storage = np.empty(source.nbytes + 1, dtype="uint8") + unaligned = np.ndarray(source.shape, dtype=source.dtype, buffer=storage, offset=1) + unaligned[:] = source + source = unaligned + elif layout == "swapped": + source = source.astype(source.dtype.newbyteorder("S")) + plan = blosc2.NativeGraph.from_expression("x * 2 + 1", {"x": "float64"}) + result, report = plan.evaluate({"x": source}, tile_items=5, return_report=True) + np.testing.assert_array_equal(result, source * 2 + 1) + assert report["normalization_bytes"] == 0 + + +@pytest.mark.parametrize("op", ["sum", "prod", "min", "max", "any", "all"]) +def test_reduction_shape_tile_and_roundtrip(op): + source = np.arange(1, 13, dtype="int8").reshape(3, 4) + plan = blosc2.NativeGraph.from_expression(f"{op}(x, axis=-1, keepdims=True)", {"x": "int8"}) + imported = blosc2.NativeGraph.from_json(plan.to_json()) + options = {"dtype": "int64"} if op in ("sum", "prod") else {} + expected = getattr(np, op)(source, axis=-1, keepdims=True, **options) + for tile in [1, 3, 8]: + actual = imported.evaluate({"x": source}, tile_items=tile) + assert actual.dtype == expected.dtype + assert actual.shape == expected.shape + assert actual.tobytes() == expected.tobytes() + + +def test_empty_broadcast_and_axis_preflight(): + plan = blosc2.NativeGraph.from_expression("x + y", {"x": "float32", "y": "float32"}) + result = plan.evaluate({"x": np.empty((0, 3), dtype="float32"), "y": np.ones((1, 3), dtype="float32")}) + assert result.shape == (0, 3) + for expression in ["sum(x, axis=[0, -2])", "sum(x, axis=2)"]: + reduction = blosc2.NativeGraph.from_expression(expression, {"x": "float32"}) + with pytest.raises(blosc2.PortableArtifactError, match=r"axis|axes"): + reduction.specialize({"x": ("float32", (2, 3))}) + + +@pytest.mark.parametrize(("expression", "expected"), [("-2 ** 2", -4), ("2.0 ** -2", 0.25)]) +def test_native_text_power_precedence(expression, expected): + plan = blosc2.NativeGraph.from_expression(expression, {}) + assert plan.evaluate({}) == expected + + +def test_weak_initial_range_error_is_runtime_only(): + plan = blosc2.NativeGraph.from_expression("min(x, initial=-1)", {"x": "uint8"}) + schedule = plan.specialize({"x": ("uint8", (1,))}) + # Native portable semantics target NumPy 2.x, independently of the installed + # host NumPy ABI; 1.26 instead warns and wraps this weak initial value. + if int(np.__version__.split(".")[0]) >= 2: + with pytest.raises(OverflowError): + np.min(np.array([1], dtype="uint8"), initial=-1) + with pytest.raises(blosc2.PortableArtifactError) as failure: + schedule.execute({"x": np.array([1], dtype="uint8")}) + assert failure.value.status == "evaluation_error" + assert failure.value.stage == 0 + + +@pytest.mark.parametrize( + "nodes", + [ + [{"op": "input", "name": "x", "dtype": "float64"}, {"op": "add", "args": [0, 2]}], + [{"op": "constant", **scalar_descriptor(1)}, {"op": "unknown", "args": [0]}], + [{"op": "constant", **scalar_descriptor(1)}, {"op": "constant", **scalar_descriptor(2)}], + [ + {"op": "input", "name": "x", "dtype": "float64"}, + {"op": "function", "name": "sqrt", "args": [0]}, + {"op": "add", "args": [1, 1]}, + ], + ], +) +def test_invalid_graphs(nodes): + with pytest.raises(blosc2.PortableArtifactError): + NativeGraphHandle(graph(nodes)) diff --git a/tests/test_native_graph_sources.py b/tests/test_native_graph_sources.py new file mode 100644 index 000000000..1201b3488 --- /dev/null +++ b/tests/test_native_graph_sources.py @@ -0,0 +1,320 @@ +"""Graph reductions stream compressed inputs without full operand materialization.""" + +import numpy as np +import pytest + +import blosc2 +from conftest import orthogonal_cases + + +@pytest.fixture(autouse=True) +def graph_sources_runtime(native_graph_runtime): + if not getattr(blosc2.blosc2_ext, "native_graph_sources_available", lambda: False)(): + pytest.skip("Installed extension does not implement graph storage readers") + + +@pytest.fixture +def parallel_sources_runtime(request, monkeypatch): + from blosc2.native_graph import prepare_native_first + + if blosc2.IS_WASM: + pytest.skip("Parallel graph reductions require threads") + backend = getattr(request.node, "callspec", None) + backend = backend.params.get("backend") if backend is not None else None + if backend is not None: + monkeypatch.setenv("ME_DSL_JIT_COMPILER", backend) + expr = blosc2.lazyexpr("x + 1", {"x": np.ones(4)}) + if prepare_native_first(expr, ()) is None: + pytest.skip("Parallel graph storage readers require an available graph JIT") + + +@pytest.mark.parametrize( + ("op", "axis", "keepdims"), + orthogonal_cases(["sum", "prod", "min", "max", "any", "all"], [None, 0, -1, ()], [False, True]), +) +def test_graph_sources_axes_broadcast_and_mixed_storage(op, axis, keepdims, monkeypatch): + values = np.arange(1, 25.0).reshape(4, 6) + x = blosc2.asarray(values, chunks=(2, 3), blocks=(1, 3)) + y = np.ones((1, 6)) + expression = f"{op}(x + y, axis={axis!r}, keepdims={keepdims!r})" + plan = blosc2.NativeGraph.from_expression(expression, {"x": "float64", "y": "float64"}, jit=True) + + def forbidden(*args, **kwargs): + pytest.fail("Graph source materialized a compressed operand") + + monkeypatch.setattr(blosc2.NDArray, "__getitem__", forbidden) + actual, report = plan.evaluate_sources({"x": x, "y": y}, tile_items=5, return_report=True) + expected = getattr(np, op)(values + y, axis=axis, keepdims=keepdims) + np.testing.assert_allclose(actual, expected) + assert report["input_materialization_bytes"] == 0 + assert report["maximum_reader_items"] <= 5 + assert report["reader_bytes"] == values.nbytes + + +@pytest.mark.parametrize("dtype", ["float32", "float64", "int32", "uint64", "bool"]) +def test_graph_sources_direct_reduction_dtype(dtype): + values = np.arange(20).astype(dtype) + x = blosc2.asarray(values, chunks=(7,), blocks=(3,)) + plan = blosc2.NativeGraph.from_expression("sum(x)", {"x": dtype}) + result, report = plan.evaluate_sources({"x": x}, tile_items=4, return_report=True) + # Native graph sums use fixed 64-bit integer accumulators, independently of + # NumPy's platform-sized defaults (32 bits for bool/int32 on WASM32). + accumulator = "int64" if values.dtype.kind in "bi" else "uint64" if values.dtype.kind == "u" else dtype + expected = np.sum(values, dtype=accumulator) + assert result.dtype == expected.dtype + assert result == expected + assert report["evaluated_tiles"] == 0 + assert report["reader_bytes"] == values.nbytes + + +def test_required_compressed_graph_is_serial_and_bounded(monkeypatch): + values = np.linspace(0, 1, 500_003) + x = blosc2.asarray(values, chunks=(100_000,), blocks=(6250,)) + expr = blosc2.lazyexpr("x + 1", {"x": x}) + + def forbidden(*args, **kwargs): + pytest.fail("Strict graph reduction materialized input") + + monkeypatch.setattr(blosc2.NDArray, "__getitem__", forbidden) + result = expr.sum(_require_native=True, jit=True) + np.testing.assert_allclose(result, np.sum(values + 1), rtol=1e-12) + report = expr._native_execution_report + assert report["route"] == "graph-bounded-readers" + assert report["input_materialization_bytes"] == 0 + assert report["maximum_reader_items"] <= report["tile_items"] + + +@pytest.mark.parametrize("backend", ["cc", "tcc"]) +@pytest.mark.parametrize("mixed", [False, True]) +@pytest.mark.parametrize("keepdims", [False, True]) +def test_automatic_compressed_graph_parallel_sum( + backend, mixed, keepdims, monkeypatch, parallel_sources_runtime +): + import blosc2.native_graph as native + from blosc2.storage_readers import StorageReader + + monkeypatch.setattr(native, "MINIMUM_COMPRESSED_GRAPH_ITEMS", 4_000_000) + monkeypatch.setenv("ME_DSL_JIT_COMPILER", backend) + values = np.linspace(0, 1, 4_200_003) + x = blosc2.asarray(values, chunks=(1_000_000,), blocks=(6250,)) + y = ( + np.ones_like(values) + if mixed + else blosc2.asarray(np.ones_like(values), chunks=x.chunks, blocks=x.blocks) + ) + expr = blosc2.lazyexpr("x + y", {"x": x, "y": y}) + previous = blosc2.set_nthreads(2) + try: + + def forbidden(*args, **kwargs): + pytest.fail("Automatic compressed graph used materialization/legacy execution") + + monkeypatch.setattr(blosc2.NDArray, "__getitem__", forbidden) + monkeypatch.setattr(StorageReader, "read", forbidden) + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + result = expr.sum(keepdims=keepdims) + np.testing.assert_allclose(result, np.sum(values + 1, keepdims=keepdims), rtol=1e-12) + report = expr._native_execution_report + assert report["route"] == "parallel-graph-bounded-readers" + assert report["threads"] == 2 + assert report["input_materialization_bytes"] == 0 + assert report["maximum_reader_items"] <= report["tile_items"] + assert report["reader_bytes"] == values.nbytes * (1 if mixed else 2) + finally: + blosc2.set_nthreads(previous) + + +def test_graph_sources_validation_precedes_reads(monkeypatch): + from blosc2.storage_readers import StorageReader + + def forbidden(*args, **kwargs): + pytest.fail("Invalid graph bindings read storage") + + monkeypatch.setattr(StorageReader, "read", forbidden) + plan = blosc2.NativeGraph.from_expression("sum(x + y)", {"x": "float64", "y": "float64"}) + x = blosc2.asarray(np.ones(8)) + y = blosc2.asarray(np.ones(7)) + with pytest.raises(blosc2.PortableArtifactError): + plan.evaluate_sources({"x": x, "y": y}) + + +def test_graph_sources_reader_failure_is_not_replayed(monkeypatch): + from blosc2.storage_readers import StorageReader + + calls = [] + + def failure(*args, **kwargs): + calls.append(True) + raise OSError("Storage read failed") + + monkeypatch.setattr(StorageReader, "read", failure) + expr = blosc2.lazyexpr("x + 1", {"x": blosc2.asarray(np.ones(20))}) + with pytest.raises(OSError, match="Storage read failed"): + expr.sum(_require_native=True) + assert calls == [True] + + +def test_graph_sources_staged_rejects_before_reads(monkeypatch): + from blosc2.storage_readers import StorageReader + + def forbidden(*args, **kwargs): + pytest.fail("Unsupported staged graph read storage") + + monkeypatch.setattr(StorageReader, "read", forbidden) + plan = blosc2.NativeGraph.from_expression("x - sum(x)", {"x": "float64"}) + with pytest.raises(ValueError, match="single-region"): + plan.evaluate_sources({"x": blosc2.asarray(np.ones(8))}) + + +def test_graph_sources_mismatched_partitions_and_initial(monkeypatch): + values = np.linspace(0, 1, 101) + x = blosc2.asarray(values, chunks=(17,), blocks=(5,)) + y = blosc2.asarray(values + 1, chunks=(23,), blocks=(7,)) + expr = blosc2.lazyexpr("x + y", {"x": x, "y": y}) + + def forbidden(*args, **kwargs): + pytest.fail("Streamed reduction materialized an operand") + + monkeypatch.setattr(blosc2.NDArray, "__getitem__", forbidden) + actual = expr.sum(initial=3, _require_native=True, jit=True) + np.testing.assert_allclose(actual, np.sum(values + values + 1, initial=3)) + assert expr._native_execution_report["input_materialization_bytes"] == 0 + + +def test_automatic_compressed_graph_persisted_native_readers( + tmp_path, monkeypatch, parallel_sources_runtime +): + import blosc2.native_graph as native + from blosc2.storage_readers import StorageReader + + monkeypatch.setattr(native, "MINIMUM_COMPRESSED_GRAPH_ITEMS", 4_000_000) + values = np.linspace(0, 1, 4_200_003) + x = blosc2.asarray(values, chunks=(1_000_000,), blocks=(6250,), urlpath=tmp_path / "x.b2nd") + expr = blosc2.lazyexpr("x + 1", {"x": x}) + previous = blosc2.set_nthreads(2) + try: + + def forbidden(*args, **kwargs): + pytest.fail("Native compressed graph called Python/materialization readers") + + monkeypatch.setattr(blosc2.NDArray, "__getitem__", forbidden) + monkeypatch.setattr(StorageReader, "read", forbidden) + for _ in range(2): + np.testing.assert_allclose(expr.sum(), np.sum(values + 1), rtol=1e-12) + assert expr._native_execution_report["route"] == "parallel-graph-bounded-readers" + assert expr._native_execution_report["input_materialization_bytes"] == 0 + finally: + blosc2.set_nthreads(previous) + + +def test_graph_sources_resident_mask_participation(monkeypatch): + values = np.arange(20.0) + x = blosc2.asarray(values, chunks=(7,), blocks=(3,)) + mask = np.arange(values.size) % 2 == 0 + plan = blosc2.NativeGraph.from_expression( + "sum(x + 1, where=mask)", {"x": "float64", "mask": "bool"}, jit=True + ) + + def forbidden(*args, **kwargs): + pytest.fail("Masked graph materialized input") + + monkeypatch.setattr(blosc2.NDArray, "__getitem__", forbidden) + result, report = plan.evaluate_sources({"x": x, "mask": mask}, tile_items=5, return_report=True) + assert result == np.sum(values[mask] + 1) + assert report["reader_bytes"] == values[mask].nbytes + assert report["maximum_reader_items"] <= 5 + + +def test_graph_sources_compressed_mask_rejected_before_reads(monkeypatch): + from blosc2.storage_readers import StorageReader + + def forbidden(*args, **kwargs): + pytest.fail("Unsupported compressed mask read storage") + + monkeypatch.setattr(StorageReader, "read", forbidden) + inputs = {"x": blosc2.asarray(np.ones(8)), "mask": blosc2.asarray(np.ones(8, dtype=bool))} + plan = blosc2.NativeGraph.from_expression("sum(x, where=mask)", {"x": "float64", "mask": "bool"}) + with pytest.raises(blosc2.PortableArtifactError): + plan.evaluate_sources(inputs) + + +def test_graph_sources_empty_domain_does_not_read(monkeypatch): + from blosc2.storage_readers import StorageReader + + def forbidden(*args, **kwargs): + pytest.fail("Empty graph read storage") + + monkeypatch.setattr(StorageReader, "read", forbidden) + plan = blosc2.NativeGraph.from_expression("sum(x + 1)", {"x": "float64"}) + result, report = plan.evaluate_sources({"x": blosc2.asarray(np.empty(0))}, return_report=True) + assert result == 0 + assert report["reader_bytes"] == report["maximum_reader_items"] == 0 + + +def test_automatic_compressed_worker_failure_is_not_replayed(monkeypatch, parallel_sources_runtime): + import blosc2.native_graph as native + import blosc2.resident_execution as resident + + class FailedPool: + def submit(self, *args, **kwargs): + from concurrent.futures import Future + + result = Future() + result.set_exception(OSError("Compressed worker failed")) + return result + + def forbidden(*args, **kwargs): + pytest.fail("Failed compressed graph replayed legacy execution") + + monkeypatch.setattr(native, "MINIMUM_COMPRESSED_GRAPH_ITEMS", 4_000_000) + monkeypatch.setattr(resident, "resident_pool", lambda: FailedPool()) + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + x = blosc2.asarray(np.ones(4_200_003), chunks=(1_000_000,), blocks=(6250,)) + previous = blosc2.set_nthreads(2) + try: + with pytest.raises(OSError, match="Compressed worker failed"): + blosc2.lazyexpr("x + 1", {"x": x}).sum() + finally: + blosc2.set_nthreads(previous) + + +def test_native_compressed_readers_acquire_gil_for_postfilters(monkeypatch, parallel_sources_runtime): + import blosc2.native_graph as native + + size = 4 * 128 * 1024 + monkeypatch.setattr(native, "MINIMUM_COMPRESSED_GRAPH_ITEMS", size) + values = (np.arange(size) % 3).astype("int32") + x = blosc2.asarray(values, chunks=(128 * 1024,), blocks=(8192,)) + x.schunk.dparams = blosc2.DParams(nthreads=1) + + @x.schunk.postfilter(np.int32, np.int32) + def make_nonzero(input, output, offset): + output[:] = input + 1 + + previous = blosc2.set_nthreads(2) + try: + expr = blosc2.lazyexpr("x", {"x": x}) + assert bool(expr.all()) + assert expr._native_execution_report["route"] == "parallel-graph-bounded-readers" + finally: + blosc2.set_nthreads(previous) + + +def test_native_span_unaligned_block_sized_requests(graph_sources_runtime): + from blosc2.storage_readers import ReaderState, StorageReader + + values = np.arange(1024, dtype=np.float64) + x = blosc2.asarray(values, chunks=(1024,), blocks=(128,)) + + class SpanReader(StorageReader): + def __init__(self): + super().__init__(x, (384,)) + self.start = 3 + self.shape = (384,) + + plan = blosc2.NativeGraph.from_expression("x + 1", {"x": "float64"}) + schedule = plan.specialize({"x": (values.dtype, (384,))}, tile_items=128) + result, report = schedule.execute_sources({"x": x}, {"x": ReaderState(SpanReader())}, native_spans=True) + np.testing.assert_array_equal(result, values[3:387] + 1) + assert report["maximum_reader_items"] == 128 + assert report["reader_bytes"] == 384 * values.itemsize diff --git a/tests/test_native_graph_stages.py b/tests/test_native_graph_stages.py new file mode 100644 index 000000000..9f750b488 --- /dev/null +++ b/tests/test_native_graph_stages.py @@ -0,0 +1,259 @@ +"""Separately declared staged subset: materialization, lifetime and budgets.""" + +import json +import sys +from concurrent.futures import ThreadPoolExecutor + +import numpy as np +import pytest + +import blosc2 +from conftest import orthogonal_cases + +pytestmark = pytest.mark.usefixtures("native_graph_runtime") + + +def test_reduction_metadata_avoids_graph_json(): + plan = blosc2.NativeGraph.from_expression("sum(x, axis=-1, keepdims=True)", {"x": "float64"}) + assert plan.reduction_info() == { + "op": "sum", + "axes": (-1,), + "keepdims": True, + "initial": False, + "where": False, + } + mapped = blosc2.NativeGraph.from_expression("x + 1", {"x": "float64"}) + assert mapped.reduction_info() is None + + +@pytest.mark.parametrize( + "expression", ["x - sum(x, axis=0)", "sum(sum(x, axis=0))", "sum(x, axis=0) + max(x, axis=0)"] +) +@pytest.mark.parametrize("dtype", ["int8", "float32", "float64"]) +def test_automatic_native_stages(expression, dtype): + x = np.arange(1, 13, dtype=dtype).reshape(3, 4) + plan = blosc2.NativeGraph.from_expression(expression, {"x": dtype}) + assert plan.info()["stages"] >= 2 + imported = blosc2.NativeGraph.from_json(plan.to_json()) + assert json.loads(imported.to_json())["format"] == "menudet-staged-graph-1" + expected = ( + x - np.sum(x, axis=0, dtype="int64" if dtype == "int8" else dtype) + if expression.startswith("x -") + else ( + np.sum(np.sum(x, axis=0, dtype="int64" if dtype == "int8" else dtype)) + if expression.startswith("sum(sum") + else np.sum(x, axis=0, dtype="int64" if dtype == "int8" else dtype) + np.max(x, axis=0) + ) + ) + for tile in [1, 5]: + result, report = imported.evaluate({"x": x}, tile_items=tile, return_report=True) + assert result.dtype == expected.dtype + assert result.shape == expected.shape + assert result.tobytes() == expected.tobytes() + assert report["stages"] == plan.info()["stages"] + assert report["intermediate_bytes"] > 0 + + +def test_native_required_staged_adapter(): + x = blosc2.asarray(np.arange(12, dtype="float32").reshape(3, 4)) + with blosc2.expression_evaluation("safe"): + expr = blosc2.lazyexpr("x - sum(x, axis=0)", {"x": x}) + result = expr.compute(_require_native=True) + np.testing.assert_array_equal(result[:], x[:] - np.sum(x[:], axis=0)) + assert expr._native_execution_report["stages"] == 2 + with pytest.raises(ValueError, match="partial"): + expr.compute(slice(1, None), _require_native=True) + + +def test_shared_stage_value_and_budget(): + graph = { + "format": "menudet-graph-1", + "semantics": "menudet-numpy-1.0", + "requires": ["numeric", "staged"], + "nodes": [ + {"id": 0, "op": "input", "name": "x", "dtype": "float32"}, + {"id": 1, "op": "function", "name": "sqrt", "args": [0]}, + {"id": 2, "op": "add", "args": [1, 1]}, + ], + "root": 2, + "output": {"dtype": "auto", "casting": "unsafe"}, + } + plan = blosc2.NativeGraph.from_json(graph) + with pytest.raises(blosc2.PortableArtifactError, match="budget"): + plan.specialize({"x": ("float32", (3,))}, intermediate_budget=11) + schedule = plan.specialize({"x": ("float32", (3,))}, intermediate_budget=12) + assert schedule.stage_info(0) == { + "shape": (3,), + "dtype": np.dtype("float32"), + "bytes": 12, + "last_consumer": 1, + } + assert schedule.info()["intermediate_bytes"] == 12 + result, report = schedule.execute({"x": np.array([1, 4, 9], dtype="float32")}) + np.testing.assert_array_equal(result, [2, 4, 6]) + assert report["evaluated_tiles"] == 2 + del plan + if sys.platform == "emscripten": + for value in range(1, 9): + result, _ = schedule.execute({"x": np.full(3, value, dtype="float32")}) + np.testing.assert_array_equal(result, np.full(3, 2 * np.sqrt(np.float32(value)))) + return + with ThreadPoolExecutor(max_workers=4) as executor: + list( + executor.map( + lambda value: schedule.execute({"x": np.full(3, value, dtype="float32")}), range(1, 9) + ) + ) + + +@pytest.mark.parametrize( + "expression", ["where(x > 0, sum(x), x)", "x and sum(x)", "sum(x - sum(x), where=mask)"] +) +def test_conditional_stage_domains_reject(expression): + inputs = {"x": "float32"} + if "mask" in expression: + inputs["mask"] = "bool" + with pytest.raises(blosc2.PortableArtifactError, match=r"conditional|masked"): + blosc2.NativeGraph.from_expression(expression, inputs) + + +def trusted_document(): + artifact = json.loads(blosc2.NativeGraph.from_expression("x * 2", {"x": "float32"}).map_json()) + graph = json.loads(blosc2.NativeGraph.from_expression("sum(y)", {"y": "float32"}).to_json()) + return { + "format": "menudet-staged-graph-1", + "semantics": "menudet-numpy-1.0", + "requires": ["numeric", "staged"], + "inputs": [{"name": "x", "dtype": "float32"}], + "root": 1, + "stages": [ + { + "id": 0, + "kind": "portable", + "inputs": {"x": {"input": "x"}}, + "artifact": artifact, + "contract": { + "cardinality": "elementwise", + "context": "none", + "effects": "ordered-lazy", + "mask": "none", + }, + }, + {"id": 1, "kind": "graph", "inputs": {"y": {"stage": 0}}, "graph": graph}, + ], + } + + +def test_trusted_portable_stage_and_roundtrip(): + plan = blosc2.NativeGraph(trusted_document()) + imported = blosc2.NativeGraph(plan.to_json()) + x = np.arange(5, dtype="float32") + result = imported.evaluate({"x": x}) + assert result == np.sum(x * 2) + + +@pytest.mark.parametrize( + ("field", "value"), + [("mask", "external"), ("effects", "pure"), ("context", "nd"), ("cardinality", "block-scalar")], +) +def test_unqualified_trusted_contract_rejects(field, value): + document = trusted_document() + document["stages"][0]["contract"][field] = value + with pytest.raises(blosc2.PortableArtifactError, match="contract"): + blosc2.NativeGraph(document) + + +def test_late_stage_status_recovery(): + plan = blosc2.NativeGraph.from_expression("sqrt(x) + sum(y)", {"x": "float64", "y": "float64"}) + schedule = plan.specialize({"x": ("float64", (3,)), "y": ("float64", (3,))}) + with pytest.raises(blosc2.PortableArtifactError) as failure: + schedule.execute({"x": np.array([-1.0, 1.0, 4.0]), "y": np.ones(3)}, 1) + if sys.platform == "emscripten": + assert "floating status unavailable" in str(failure.value) + result, _ = schedule.execute({"x": np.array([-1.0, 1.0, 4.0]), "y": np.ones(3)}) + np.testing.assert_array_equal(result, [np.nan, 4, 5]) + else: + assert failure.value.fp_status["flags"] & 1 + result, report = schedule.execute( + {"x": np.array([0.0, 1.0, 4.0]), "y": np.ones(3)}, + 0 if sys.platform == "emscripten" else 1, + ) + np.testing.assert_array_equal(result, [3, 4, 5]) + assert not report["fp_flags"] + + +@pytest.mark.parametrize( + ("name", "layout"), + orthogonal_cases(["sum", "prod", "min", "max", "any", "all"], ["c", "f", "reverse", "step", "swapped"]), +) +def test_staged_reducers_and_layouts(name, layout): + x = np.arange(12, dtype="float32").reshape(3, 4) + if layout == "f": + x = np.asfortranarray(x) + elif layout == "reverse": + x = x[::-1, ::-1] + elif layout == "step": + x = x[:, ::2] + elif layout == "swapped": + x = x.astype(">f4") + expression = f"{name}(x, axis=-1, keepdims=True) + x" + plan = blosc2.NativeGraph.from_expression(expression, {"x": "float32"}) + expected = getattr(np, name)(x.astype("float32"), axis=-1, keepdims=True) + x + for tile in [1, 7]: + result = plan.evaluate({"x": x}, tile_items=tile) + assert result.dtype == expected.dtype + np.testing.assert_array_equal(result, expected) + + +@pytest.mark.parametrize("shape", [(0, 4), (2, 0), ()]) +def test_empty_and_rank_zero_stages(shape): + x = np.zeros(shape, dtype="float64") + plan = blosc2.NativeGraph.from_expression("sum(x) + x", {"x": "float64"}) + result = plan.evaluate({"x": x}) + np.testing.assert_array_equal(result, np.sum(x) + x) + assert result.shape == shape + + +@pytest.mark.parametrize( + "mutation", ["cycle", "missing", "signature", "unreachable", "root", "capability", "nested"] +) +def test_staged_dependency_validation(mutation): + document = trusted_document() + if mutation == "cycle": + document["stages"][0]["inputs"]["x"] = {"stage": 1} + elif mutation == "missing": + document["stages"][1]["inputs"] = {} + elif mutation == "signature": + document["inputs"][0]["dtype"] = "float64" + elif mutation == "unreachable": + document["stages"][1]["inputs"]["y"] = {"input": "x"} + elif mutation == "root": + document["root"] = 0 + elif mutation == "capability": + document["requires"] = ["numeric"] + else: + document["stages"][1]["graph"] = trusted_document() + with pytest.raises(blosc2.PortableArtifactError): + blosc2.NativeGraph(document) + + +def test_staged_map_export_and_required_jit(): + expression = "x - sum(x)" + plan = blosc2.NativeGraph.from_expression(expression, {"x": "float32"}, jit=True) + if plan.has_jit: + plan = blosc2.NativeGraph.from_expression(expression, {"x": "float32"}, require_jit=True) + assert plan.has_jit + else: + with pytest.raises(blosc2.PortableArtifactError, match="required map JIT"): + blosc2.NativeGraph.from_expression(expression, {"x": "float32"}, require_jit=True) + with pytest.raises(ValueError, match="elementwise"): + plan.map_json() + result, report = plan.evaluate({"x": np.arange(5, dtype="float32")}, return_report=True) + np.testing.assert_array_equal(result, [-10, -9, -8, -7, -6]) + assert report["jit_stages"] + report["interpreter_stages"] == 2 + if plan.has_jit: + # The direct-input sum bypasses its identity map; only subtraction + # executes JIT code, even if both prepared maps are JIT-capable. + assert report["jit_stages"] == 1 + else: + assert report["interpreter_stages"] >= 1 diff --git a/tests/test_native_graph_truth.py b/tests/test_native_graph_truth.py new file mode 100644 index 000000000..67793d637 --- /dev/null +++ b/tests/test_native_graph_truth.py @@ -0,0 +1,212 @@ +"""Parallel any/all evaluate all regions and preserve native status and failures.""" + +import numpy as np +import pytest + +import blosc2 +from blosc2.native_graph import prepare_native_first +from conftest import orthogonal_cases + + +@pytest.fixture(autouse=True) +def graph_truth_runtime(native_graph_runtime, request, monkeypatch): + if blosc2.IS_WASM: + pytest.skip("Parallel graph reductions require threads") + backend = getattr(request.node, "callspec", None) + backend = backend.params.get("backend") if backend is not None else None + if backend is not None: + monkeypatch.setenv("ME_DSL_JIT_COMPILER", backend) + expr = blosc2.lazyexpr("x > 0", {"x": np.ones(4)}) + if prepare_native_first(expr, ()) is None: + pytest.skip("Parallel graph truth reductions require an available graph JIT") + + +@pytest.mark.parametrize("op", ["any", "all"]) +@pytest.mark.parametrize( + ("dtype", "backend", "keepdims"), + orthogonal_cases( + ["bool", "int8", "int64", "uint64", "float32", "float64"], ["cc", "tcc"], [False, True] + ), +) +def test_parallel_resident_truth(op, dtype, backend, keepdims, monkeypatch): + monkeypatch.setenv("ME_DSL_JIT_COMPILER", backend) + values = (np.arange(4 * 128 * 1024) % 3).astype(dtype).reshape(4, -1) + expr = blosc2.lazyexpr("x", {"x": values}) + previous = blosc2.set_nthreads(2) + try: + result = getattr(expr, op)(axis=(0, 1), keepdims=keepdims) + expected = getattr(np, op)(values, axis=(0, 1), keepdims=keepdims) + np.testing.assert_array_equal(result, expected) + assert result.dtype == np.dtype("bool") + assert result.shape == expected.shape + assert expr._native_execution_report["route"] == "parallel-resident-reduction" + assert expr._native_execution_report["threads"] == 2 + serial = getattr(expr, op)(axis=(0, 1), keepdims=keepdims, _require_native=True, jit=True) + assert result.tobytes() == serial.tobytes() + assert expr._native_execution_report.get("route") != "parallel-resident-reduction" + finally: + blosc2.set_nthreads(previous) + + +@pytest.mark.parametrize("op", ["any", "all"]) +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("backend", ["cc", "tcc"]) +def test_parallel_truth_late_fp_status_is_not_short_circuited(op, dtype, backend, monkeypatch): + monkeypatch.setenv("ME_DSL_JIT_COMPILER", backend) + x = np.full(4 * 128 * 1024, 1 if op == "any" else 0, dtype=dtype) + y = np.ones_like(x) + # The first region decides the Boolean result, but the second still performs + # inf*0. Its invalid-operation flag must be recorded, not skipped. + x[x.size // 2] = np.inf + y[x.size // 2] = 0 + expr = blosc2.lazyexpr("x * y", {"x": x, "y": y}) + previous = blosc2.set_nthreads(2) + try: + serial = getattr(expr, op)(_require_native=True, jit=True) + flags = expr._native_execution_report["fp_flags"] + result = getattr(expr, op)() + assert bool(result) == (op == "any") + assert result.tobytes() == serial.tobytes() + assert expr._native_execution_report["route"] == "parallel-resident-reduction" + assert expr._native_execution_report["fp_flags"] == flags + assert flags & 1 + finally: + blosc2.set_nthreads(previous) + + +@pytest.mark.parametrize("op", ["any", "all"]) +@pytest.mark.parametrize( + ("dtype", "backend", "root_expression"), + orthogonal_cases(["bool", "int32", "uint64", "float32", "float64"], ["cc", "tcc"], [False, True]), +) +def test_parallel_compressed_truth(op, dtype, backend, root_expression, monkeypatch): + import blosc2.native_graph as native + from blosc2.storage_readers import StorageReader + + if not getattr(blosc2.blosc2_ext, "native_graph_sources_available", lambda: False)(): + pytest.skip("Installed extension does not implement graph storage readers") + monkeypatch.setattr(native, "MINIMUM_COMPRESSED_GRAPH_ITEMS", 4 * 128 * 1024) + monkeypatch.setenv("ME_DSL_JIT_COMPILER", backend) + values = (np.arange(4 * 128 * 1024 + 7) % 3).astype(dtype) + x = blosc2.asarray(values, chunks=(128 * 1024,), blocks=(8192,)) + expression = f"{op}(x)" if root_expression else "x" + expr = blosc2.lazyexpr(expression, {"x": x}) + previous = blosc2.set_nthreads(2) + try: + + def forbidden(*args, **kwargs): + pytest.fail("Compressed truth reduction used Python/materialization/legacy execution") + + monkeypatch.setattr(blosc2.NDArray, "__getitem__", forbidden) + monkeypatch.setattr(StorageReader, "read", forbidden) + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + result = expr.compute() if root_expression else getattr(expr, op)() + assert result.dtype == np.dtype("bool") + assert bool(result) == bool(getattr(np, op)(values)) + report = expr._native_execution_report + assert report["route"] == "parallel-graph-bounded-readers" + assert report["threads"] == 2 + assert report["reader_bytes"] == values.nbytes + assert report["maximum_reader_items"] <= report["tile_items"] + assert report["input_materialization_bytes"] == 0 + finally: + blosc2.set_nthreads(previous) + + +@pytest.mark.parametrize("op", ["any", "all"]) +def test_parallel_truth_late_worker_failure_is_not_short_circuited(op, monkeypatch): + import blosc2.resident_execution as resident + + submissions = [] + + class FailedLaterPool: + def submit(self, operation, inputs): + from concurrent.futures import Future + + result = Future() + submissions.append(True) + if len(submissions) == 1: + result.set_result(operation(inputs)) + else: + result.set_exception(OSError("Later truth worker failed")) + return result + + monkeypatch.setattr(resident, "resident_pool", lambda: FailedLaterPool()) + previous = blosc2.set_nthreads(2) + try: + values = np.full(4 * 128 * 1024, op == "any", dtype=bool) + expr = blosc2.lazyexpr("x", {"x": values}) + with pytest.raises(OSError, match="Later truth worker failed"): + getattr(expr, op)() + assert len(submissions) == 2 + finally: + blosc2.set_nthreads(previous) + + +@pytest.mark.parametrize("op", ["any", "all"]) +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("backend", ["cc", "tcc"]) +def test_parallel_truth_direct_snan_status_matches_serial(op, dtype, backend, monkeypatch): + monkeypatch.setenv("ME_DSL_JIT_COMPILER", backend) + values = np.full(4 * 128 * 1024, 1 if op == "any" else 0, dtype=dtype) + values.view("uint32" if dtype == "float32" else "uint64")[values.size // 2] = ( + 0x7F800011 if dtype == "float32" else 0x7FF0000000000011 + ) + expr = blosc2.lazyexpr("x", {"x": values}) + previous = blosc2.set_nthreads(2) + try: + serial = getattr(expr, op)(_require_native=True, jit=True) + flags = expr._native_execution_report["fp_flags"] + result = getattr(expr, op)() + assert result.tobytes() == serial.tobytes() + assert expr._native_execution_report["fp_flags"] == flags + assert expr._native_execution_report["route"] == "parallel-resident-reduction" + finally: + blosc2.set_nthreads(previous) + + +@pytest.mark.parametrize("op", ["any", "all"]) +@pytest.mark.parametrize("dtype", ["int32", "float32", "float64"]) +def test_parallel_truth_comparison_maps(op, dtype): + values = np.arange(4 * 128 * 1024).astype(dtype) + expr = blosc2.lazyexpr("x > y", {"x": values, "y": np.ones_like(values)}) + previous = blosc2.set_nthreads(2) + try: + result = getattr(expr, op)() + assert bool(result) == bool(getattr(np, op)(values > 1)) + assert expr._native_execution_report["route"] == "parallel-resident-reduction" + finally: + blosc2.set_nthreads(previous) + + +@pytest.mark.parametrize("op", ["any", "all"]) +def test_parallel_compressed_truth_preserves_late_status(op, monkeypatch): + import blosc2.native_graph as native + + if not getattr(blosc2.blosc2_ext, "native_graph_sources_available", lambda: False)(): + pytest.skip("Installed extension does not implement graph storage readers") + size = 4 * 128 * 1024 + monkeypatch.setattr(native, "MINIMUM_COMPRESSED_GRAPH_ITEMS", size) + values = np.full(size, 1 if op == "any" else 0, dtype="float64") + factor = np.ones_like(values) + values[size // 2] = np.inf + factor[size // 2] = 0 + inputs = { + name: blosc2.asarray(value, chunks=(128 * 1024,), blocks=(8192,)) + for name, value in {"x": values, "y": factor}.items() + } + expr = blosc2.lazyexpr("x * y", inputs) + previous = blosc2.set_nthreads(2) + try: + serial = getattr(expr, op)(_require_native=True, jit=True) + flags = expr._native_execution_report["fp_flags"] + result = getattr(expr, op)() + assert result.tobytes() == serial.tobytes() + report = expr._native_execution_report + assert report["fp_flags"] == flags + assert flags & 1 + assert report["reader_bytes"] == 2 * values.nbytes + assert report["input_materialization_bytes"] == 0 + assert report["route"] == "parallel-graph-bounded-readers" + finally: + blosc2.set_nthreads(previous) diff --git a/tests/test_native_graph_weak_captures.py b/tests/test_native_graph_weak_captures.py new file mode 100644 index 000000000..f4eb064d6 --- /dev/null +++ b/tests/test_native_graph_weak_captures.py @@ -0,0 +1,94 @@ +"""JIT specialization of immutable weak integers never relaxes range checks.""" + +import numpy as np +import pytest + +import blosc2 +from blosc2.native_graph import scalar_descriptor + +pytestmark = pytest.mark.usefixtures("native_graph_runtime") + + +@pytest.mark.parametrize("dtype", ["int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64"]) +def test_weak_integral_capture_boundaries(dtype): + limits = np.iinfo(dtype) + # Weak integer transport is signed int64, even next to uint64 arrays. + values = (max(int(limits.min), -(2**63)), min(int(limits.max), 2**63 - 1), 1) + x = np.array([0, 1, 2], dtype=dtype) + oracle = blosc2.NativeGraph.from_expression("x + x", {"x": dtype}, jit=True) + for value in values: + expression = f"x + {value}" + plan = blosc2.NativeGraph.from_expression(expression, {"x": dtype}, jit=True) + reference = blosc2.NativeGraph.from_expression(expression, {"x": dtype}, jit=False) + if oracle.has_jit: + assert plan.has_jit + for tile in (1, 64): + result, report = plan.evaluate({"x": x}, tile_items=tile, return_report=True) + expected = reference.evaluate({"x": x}, tile_items=tile) + assert result.dtype == expected.dtype + assert result.tobytes() == expected.tobytes() + if oracle.has_jit: + assert report["jit_stages"] == 1 + restored = blosc2.NativeGraph.from_json(plan.to_json(), jit=True) + assert restored.evaluate({"x": x}).tobytes() == expected.tobytes() + + +@pytest.mark.parametrize( + ("dtype", "expression"), [("int32", "x % 7"), ("int32", "x << 2"), ("int8", "int16(x) * 2")] +) +def test_graph_benchmark_integer_cases_jit(dtype, expression): + oracle = blosc2.NativeGraph.from_expression("x + x", {"x": dtype}, jit=True) + plan = blosc2.NativeGraph.from_expression(expression, {"x": dtype}, jit=True) + reference = blosc2.NativeGraph.from_expression(expression, {"x": dtype}, jit=False) + if oracle.has_jit: + assert plan.has_jit + x = np.array([-10, -3, 0, 5, 20], dtype=dtype) + assert plan.evaluate({"x": x}).tobytes() == reference.evaluate({"x": x}).tobytes() + + +@pytest.mark.parametrize(("dtype", "value"), [("int8", 128), ("int8", -129), ("uint8", -1), ("uint8", 256)]) +def test_out_of_range_weak_capture_keeps_lazy_fallback(dtype, value): + plan = blosc2.NativeGraph.from_expression(f"where(x == 0, x, x + {value})", {"x": dtype}, jit=True) + assert not plan.has_jit + zero = np.zeros(3, dtype=dtype) + np.testing.assert_array_equal(plan.evaluate({"x": zero}), zero) + active = zero.copy() + active[1] = 1 + with pytest.raises(blosc2.PortableArtifactError): + plan.evaluate({"x": active}) + # No failure poisons the immutable plan or changes later branch participation. + np.testing.assert_array_equal(plan.evaluate({"x": zero}), zero) + + +def test_bool_capture_is_checked_before_integer_specialization(): + record = { + "format": "menudet-graph-1", + "semantics": "menudet-numpy-1.0", + "requires": ["numeric"], + "nodes": [ + {"id": 0, "op": "input", "name": "x", "dtype": "int8"}, + {"id": 1, "op": "constant", **scalar_descriptor(True)}, + {"id": 2, "op": "add", "args": [0, 1]}, + ], + "root": 2, + "output": {"dtype": "auto", "casting": "unsafe"}, + } + plan = blosc2.NativeGraph.from_json(record, jit=True) + x = np.array([0, 1, 2], dtype="int8") + np.testing.assert_array_equal(plan.evaluate({"x": x}), [1, 2, 3]) + + +def test_capture_values_are_part_of_jit_cache_identity(): + source = blosc2.DSLKernel.from_source("def k(x, c):\n return x % c\n") + x = np.array([-10, -3, 0, 5, 20], dtype="int32") + oracle = blosc2.NativeGraph.from_expression("x + x", {"x": "int32"}, jit=True) + kernels = [] + for value in (7, 3, 11, 7): + artifact = source.export({"x": "int32"}, "int32", constants={"c": value}, version="1.0") + kernel = blosc2.PortableKernel.from_json(artifact, jit=True) + if oracle.has_jit: + assert kernel.has_jit + kernels.append((kernel, value)) + # Keep all kernels alive while compiling others and replay in reverse order. + for kernel, value in reversed(kernels): + np.testing.assert_array_equal(kernel.evaluate_block({"x": x}), x % value) diff --git a/tests/test_native_plan_cache.py b/tests/test_native_plan_cache.py new file mode 100644 index 000000000..574b4d306 --- /dev/null +++ b/tests/test_native_plan_cache.py @@ -0,0 +1,138 @@ +"""Prepared native-plan reuse stays bounded, operand-free and output-safe.""" + +import gc +import weakref +from concurrent.futures import ThreadPoolExecutor +from types import SimpleNamespace + +import numpy as np +import pytest + +import blosc2 +from blosc2 import native_graph + + +def _plan_cache(): + return native_graph._native_plan_cache + + +def _compute_plan(expression, inputs, out=None): + """Exercise the graph adapter; evaluate can use the separate resident schedule cache.""" + expr = blosc2.lazyexpr(expression, inputs) + options = {"_getitem": True} + if out is not None: + options["out"] = out + prepared = native_graph.prepare_native_first(expr, (), jit=False, options=options) + if prepared is None: + return None + return native_graph.compute_native_graph( + expr, prepared=prepared, jit=False, parallel_reductions=True, **options + ) + + +def test_plan_cache_rebinds_same_signature(native_graph_runtime): + native_graph._native_plan_cache.clear() + x = np.arange(1000, dtype="float64") + out = np.empty_like(x) + assert _compute_plan("x * 2 + 1", {"x": x}, out=out) is out + np.testing.assert_array_equal(out, x * 2 + 1) + assert len(_plan_cache()) == 1 + plan, names, reduction = next(iter(_plan_cache().values())) + assert len(names) == 1 + assert not reduction + + y = x + 7 + assert _compute_plan("x * 2 + 1", {"x": y}, out=out) is out + np.testing.assert_array_equal(out, y * 2 + 1) + assert len(_plan_cache()) == 1 + assert next(iter(_plan_cache().values()))[0] is plan + + +def test_plan_cache_key_changes_with_dtype_and_shape(native_graph_runtime): + native_graph._native_plan_cache.clear() + for value in ( + np.arange(12, dtype="float64"), + np.arange(12, dtype="float32"), + np.arange(13, dtype="float64"), + ): + np.testing.assert_array_equal(_compute_plan("x + 1", {"x": value}), value + 1) + assert len(_plan_cache()) == 3 + + +def test_plan_cache_does_not_retain_operands(native_graph_runtime): + native_graph._native_plan_cache.clear() + x = np.arange(32, dtype="float64") + reference = weakref.ref(x) + _compute_plan("x + 1", {"x": x}) + del x + gc.collect() + assert reference() is None + assert len(_plan_cache()) == 1 + + +def test_cached_plan_rejects_aliased_output(native_graph_runtime): + native_graph._native_plan_cache.clear() + x = np.arange(32, dtype="float64") + _compute_plan("x + 1", {"x": x}) + assert len(_plan_cache()) == 1 + assert _compute_plan("x + 1", {"x": x}, out=x) is None + expected = x + 1 + blosc2.evaluate("x + 1", local_dict={"x": x}, out=x) + np.testing.assert_array_equal(x, expected) + + +@pytest.mark.parametrize("jit", [False, True]) +@pytest.mark.parametrize("setting", ["ME_SIMD_MATH_BACKEND", "ME_DSL_FP_MODE"]) +def test_math_policy_invalidates_preparation_cache(monkeypatch, jit, setting): + monkeypatch.delenv(setting, raising=False) + first = native_graph._graph_configuration(jit) + operand = np.arange(16.0) + expr = SimpleNamespace(expression="x + 1", operands={"x": operand}) + key = native_graph._native_plan_cache_key(expr, jit, {}) + monkeypatch.setenv(setting, "system" if setting == "ME_SIMD_MATH_BACKEND" else "strict") + assert native_graph._graph_configuration(jit) != first + assert native_graph._native_plan_cache_key(expr, jit, {}) != key + + +def test_cache_rejects_lookalike_operand_types(): + lookalike = type("NDArray", (), {})() + expr = SimpleNamespace(expression="x + 1", operands={"x": lookalike}) + assert native_graph._native_plan_cache_key(expr, False, {}) is None + + +def test_cache_eviction_is_bounded(monkeypatch, native_graph_runtime): + native_graph._native_plan_cache.clear() + monkeypatch.setattr(native_graph, "_NATIVE_PLAN_CACHE_SIZE", 2) + x = np.arange(32.0) + inserted = [] + for constant in range(4): + np.testing.assert_array_equal(_compute_plan(f"x + {constant}", {"x": x}), x + constant) + assert len(_plan_cache()) <= 2 + inserted.append(next(reversed(_plan_cache()))) + assert list(_plan_cache()) == inserted[-2:] + + +def test_cached_plan_rebinds_strided_inputs_and_outputs(native_graph_runtime): + native_graph._native_plan_cache.clear() + base = np.arange(64.0) + for x in (base[:32].copy(), base[::2], base[:32][::-1]): + out = np.empty_like(x)[::-1] + assert _compute_plan("x + 1", {"x": x}, out=out) is out + np.testing.assert_array_equal(out, x + 1) + assert len(_plan_cache()) == 1 + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Host thread pools unavailable on WASM") +def test_cached_plan_concurrent_bindings(native_graph_runtime): + native_graph._native_plan_cache.clear() + _compute_plan("x + 1", {"x": np.arange(4096.0)}) + + def run(value): + x = np.full(4096, value, dtype="float64") + out = np.empty_like(x) + assert _compute_plan("x + 1", {"x": x}, out=out) is out + np.testing.assert_array_equal(out, value + 1) + + with ThreadPoolExecutor(max_workers=4) as pool: + list(pool.map(run, range(24))) + assert len(_plan_cache()) == 1 diff --git a/tests/test_native_preparation_types.py b/tests/test_native_preparation_types.py new file mode 100644 index 000000000..aa6f6aa6d --- /dev/null +++ b/tests/test_native_preparation_types.py @@ -0,0 +1,151 @@ +"""Shared native preparation binds numerical types without dummy-array evaluation.""" + +import importlib + +import numpy as np +import pytest + +import blosc2 + +lazy = importlib.import_module("blosc2.lazyexpr") +native = importlib.import_module("blosc2.native_graph") +NUMERIC_TYPES = [ + "bool", + "int8", + "uint8", + "int16", + "uint16", + "int32", + "uint32", + "int64", + "uint64", + "float32", + "float64", +] + + +@pytest.fixture(autouse=True) +def runtime(native_graph_runtime): + lazy._evaluate_recipe_cache.clear() + yield + lazy._evaluate_recipe_cache.clear() + + +@pytest.mark.parametrize("dtype", NUMERIC_TYPES) +def test_numeric_resident_dispatch_and_output_type(dtype, monkeypatch): + x = np.arange(17).astype(dtype) + y = np.arange(1, 18).astype(dtype) + expression = "x ^ y" if dtype == "bool" else "x + (y - 1)" + expected = x ^ y if dtype == "bool" else x + (y - 1) + + def forbidden(*args, **kwargs): + pytest.fail("Native preparation evaluated dummy operands or repeated syntax admission") + + with monkeypatch.context() as patch: + patch.setattr(lazy, "_numpy_eval_expr", forbidden) + patch.setattr(native, "_native_first_syntax", forbidden) + expr = blosc2.lazyexpr(expression, {"x": x, "y": y}) + assert expr.dtype == expected.dtype + assert hasattr(expr, "_resident_native") + actual = blosc2.evaluate(expression, local_dict={"x": x, "y": y}) + assert actual.dtype == expected.dtype + np.testing.assert_array_equal(actual, expected) + np.testing.assert_array_equal(expr[:], expected) + assert expr._native_execution_report["route"] == "native-resident" + + +@pytest.mark.parametrize("dtype", ["int64", "uint64", "float32", "float64"]) +def test_compressed_metadata_plan_keeps_execution_admission(dtype, monkeypatch): + x = np.arange(257).astype(dtype) + y = x + 1 + inputs = { + "x": blosc2.asarray(x, chunks=(128,), blocks=(32,)), + "y": blosc2.asarray(y, chunks=(128,), blocks=(32,)), + } + + def forbidden(*args, **kwargs): + pytest.fail("Metadata preparation read or evaluated operands") + + with monkeypatch.context() as patch: + patch.setattr(lazy, "_numpy_eval_expr", forbidden) + patch.setattr(blosc2.NDArray, "__getitem__", forbidden) + expr = blosc2.lazyexpr("x + (y - 1)", inputs) + assert hasattr(expr, "_metadata_native") + assert not hasattr(expr, "_prepared_native") + assert expr.dtype == x.dtype + expected = x + (y - 1) + np.testing.assert_array_equal(expr[:], expected) + np.testing.assert_array_equal(expr.compute()[:], expected) + + +@pytest.mark.parametrize("dtype", NUMERIC_TYPES) +def test_division_infers_output_separately_from_inputs(dtype): + x = np.array([9, 12], dtype=dtype) + y = np.array([2, 5], dtype=dtype) + expected = x / y + expr = blosc2.lazyexpr("x / y", {"x": x, "y": y}) + assert expr.dtype == expected.dtype + assert hasattr(expr, "_resident_native") + actual = blosc2.evaluate("x / y", local_dict={"x": x, "y": y}) + assert actual.dtype == expected.dtype + np.testing.assert_array_equal(actual, expected) + out = np.empty_like(expected) + assert blosc2.evaluate("x / y", local_dict={"x": x, "y": y}, out=out) is out + np.testing.assert_array_equal(out, expected) + + +@pytest.mark.parametrize(("left", "right"), [("int8", "int64"), ("int64", "uint64"), ("int32", "float32")]) +def test_mixed_input_types_keep_numpy_promotion(left, right): + x, y = np.arange(17).astype(left), np.arange(17).astype(right) + expected = x + y + expr = blosc2.lazyexpr("x + y", {"x": x, "y": y}) + assert hasattr(expr, "_resident_native") + assert expr.dtype == expected.dtype + np.testing.assert_array_equal(expr[:], expected) + actual = blosc2.evaluate("x + y", local_dict={"x": x, "y": y}) + assert actual.dtype == expected.dtype + np.testing.assert_array_equal(actual, expected) + + +@pytest.mark.parametrize("dtype", ["int64", "uint64"]) +def test_integer_extrema_preserve_modular_arithmetic(dtype): + limits = np.iinfo(dtype) + x = np.array([limits.max, limits.min, limits.max - 1], dtype=dtype) + y = np.array([1, 1, 2], dtype=dtype) + actual = blosc2.evaluate("x + y", local_dict={"x": x, "y": y}) + assert actual.dtype == x.dtype + np.testing.assert_array_equal(actual, x + y) + + +def test_same_width_dtype_change_invalidates_resident_schedule(): + x = np.arange(17, dtype="int64") + expr = blosc2.lazyexpr("x + 1", {"x": x}) + signed = expr[:] + expr.operands["o0"] = np.array([2**63 + 7] * 17, dtype="uint64") + unsigned = expr[:] + assert signed.dtype == np.dtype("int64") + assert unsigned.dtype == np.dtype("uint64") + np.testing.assert_array_equal(unsigned, expr.operands["o0"] + 1) + + +def test_integer_division_rejects_integer_destination_without_writing(): + x = np.arange(1, 18, dtype="int64") + out = np.full_like(x, -1) + with pytest.raises(TypeError, match="Cannot cast result"): + blosc2.evaluate("x / 2", local_dict={"x": x}, out=out) + np.testing.assert_array_equal(out, -1) + + +@pytest.mark.parametrize("expression", ["x @ y", "not x", "x[:2]", "x and y"]) +def test_non_elementwise_syntax_keeps_legacy_preparation(expression): + graph = importlib.import_module("blosc2.expression_graph").parse_expression(expression) + assert not graph.arithmetic + + +@pytest.mark.parametrize(("dtype", "constant"), [("int8", 128), ("uint8", -1), ("uint64", -1)]) +def test_out_of_range_weak_scalar_keeps_overflow_error(dtype, constant): + if np.lib.NumpyVersion(np.__version__) < "2.0.0": + pytest.skip("Menudet follows NumPy 2 weak-scalar overflow diagnostics, not NumPy 1 wrapping") + x = np.arange(3, dtype=dtype) + with pytest.raises(OverflowError): + blosc2.evaluate(f"x + ({constant})", local_dict={"x": x}) diff --git a/tests/test_native_qualification_evidence.py b/tests/test_native_qualification_evidence.py new file mode 100644 index 000000000..f748509e4 --- /dev/null +++ b/tests/test_native_qualification_evidence.py @@ -0,0 +1,68 @@ +"""Qualification cannot be borrowed from another SHA or from a lightweight gate.""" + +import importlib.util +from pathlib import Path + +import pytest + +spec = importlib.util.spec_from_file_location( + "native_qualification", Path(__file__).parents[1] / "scripts" / "verify_native_qualification.py" +) +qualification = importlib.util.module_from_spec(spec) +spec.loader.exec_module(qualification) + + +@pytest.mark.parametrize("sha", ["main", "abc123", "A" * 40]) +def test_exact_revision_required(sha): + with pytest.raises(ValueError, match="exact"): + qualification.verify(sha, lambda _: pytest.fail("Invalid SHA must not call GitHub")) + + +@pytest.mark.parametrize("conclusion", ["success", "skipped", "failure"]) +def test_full_gate_required(conclusion): + sha = "a" * 40 + + def get(path): + if "workflows" in path: + return { + "workflow_runs": [{"head_sha": sha, "conclusion": "success", "id": 42, "html_url": "url"}] + } + return { + "total_count": 1, + "jobs": [ + { + "name": "Publish full native qualification", + "status": "completed", + "conclusion": conclusion, + } + ], + } + + if conclusion == "success": + assert qualification.verify(sha, get)["run_id"] == 42 + else: + with pytest.raises(RuntimeError, match="full miniexpr"): + qualification.verify(sha, get) + + +def test_other_revision_not_accepted(): + with pytest.raises(RuntimeError): + qualification.verify( + "a" * 40, lambda _: {"workflow_runs": [{"head_sha": "b" * 40, "conclusion": "success"}]} + ) + + +@pytest.mark.parametrize( + ("name", "status"), + [("Compact native gate", "completed"), ("Publish full native qualification", "in_progress")], +) +def test_lightweight_or_unfinished_job_not_accepted(name, status): + sha = "a" * 40 + + def get(path): + if "workflows" in path: + return {"workflow_runs": [{"head_sha": sha, "conclusion": "success", "id": 42}]} + return {"total_count": 1, "jobs": [{"name": name, "status": status, "conclusion": "success"}]} + + with pytest.raises(RuntimeError, match="full miniexpr"): + qualification.verify(sha, get) diff --git a/tests/test_no_numexpr.py b/tests/test_no_numexpr.py new file mode 100644 index 000000000..17a93ca90 --- /dev/null +++ b/tests/test_no_numexpr.py @@ -0,0 +1,195 @@ +"""NumExpr installation must not affect runtime import or expression dispatch.""" + +import ast +import importlib.metadata +import json +import runpy +import subprocess +import sys +import textwrap +from pathlib import Path + +import numpy as np +import pytest + +import blosc2 + + +def test_package_has_no_numexpr_import_or_requirement(): + package = Path(blosc2.__file__).parent + imports = [] + for source in package.glob("*.py"): + tree = ast.parse(source.read_text(), filename=str(source)) + for node in ast.walk(tree): + names = ( + [alias.name for alias in node.names] + if isinstance(node, ast.Import) + else [node.module or ""] + if isinstance(node, ast.ImportFrom) + else [] + ) + if any(name.split(".")[0] == "numexpr" for name in names): + imports.append(f"{source.name}:{node.lineno}") + assert not imports + requirements = importlib.metadata.requires("blosc2") or [] + assert not any(item.lower().startswith("numexpr") for item in requirements) + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Subprocess isolation is unavailable on WASM") +@pytest.mark.parametrize("installed", [False, True]) +@pytest.mark.parametrize("split_package", [False, True]) +def test_runtime_never_imports_numexpr(installed, split_package): + source = textwrap.dedent(""" + import sys, json, importlib.abc, importlib.util, types, os + sys.path[:] = json.loads(sys.argv[1]) + if sys.argv[2] == "installed": + try: + import numexpr + except ImportError: + class ForbiddenNumExpr(types.ModuleType): + def __getattr__(self, name): + if name.startswith("__"): + raise AttributeError(name) + raise AssertionError("Unexpected NumExpr access: " + name) + sys.modules["numexpr"] = ForbiddenNumExpr("numexpr") + else: + def forbidden(*args, **kwargs): + raise AssertionError("Unexpected NumExpr backend/thread call") + for name in ("evaluate", "re_evaluate", "validate", "NumExpr", "set_num_threads"): + setattr(numexpr, name, forbidden) + os.environ["NUMEXPR_MAX_THREADS"] = "1" + os.environ["NUMEXPR_NUM_THREADS"] = "1" + class BlockNumExpr(importlib.abc.MetaPathFinder): + def find_spec(self, fullname, path=None, target=None): + if fullname == "numexpr" or fullname.startswith("numexpr."): + raise AssertionError("Unexpected NumExpr runtime import") + sys.meta_path.insert(0, BlockNumExpr()) + import numpy as np + package = json.loads(sys.argv[3]) + spec = importlib.util.spec_from_file_location( + "blosc2", package["origin"], submodule_search_locations=package["paths"]) + blosc2 = importlib.util.module_from_spec(spec) + sys.modules["blosc2"] = blosc2 + spec.loader.exec_module(blosc2) + assert blosc2.numexpr is None + x = np.arange(24.).reshape(4,6) + for order in ("C", "F"): + result=blosc2.evaluate("x * 2 + 1", local_dict={"x":x}, order=order) + np.testing.assert_array_equal(result,x*2+1) + stored=blosc2.asarray(x) + np.testing.assert_array_equal(blosc2.evaluate("x + 1",local_dict={"x":stored}),x+1) + out=np.empty(x.shape,dtype="complex128") + assert blosc2.evaluate("complex(x,x)",local_dict={"x":x},out=out) is out + np.testing.assert_array_equal(out.real,x) + np.testing.assert_array_equal(out.imag,x) + mixed=blosc2.evaluate("a + b",local_dict={"a":stored,"b":x}) + np.testing.assert_array_equal(mixed,2*x) + words=np.array(["red", "blue", "red"]) + np.testing.assert_array_equal( + blosc2.evaluate("contains(words, 'red')",local_dict={"words":words}), + [True,False,True]) + dates=np.array(["2026-01-01", "NaT"],dtype="datetime64[D]") + np.testing.assert_array_equal( + blosc2.evaluate("dates == dates",local_dict={"dates":dates}),[True,False]) + with blosc2.jit_options(jit=False): + graph=blosc2.NativeGraph.from_expression("x * 2 + 1",{"x":"float64"},jit=False) + result,report=graph.evaluate({"x":x},out=np.empty_like(x),return_report=True) + np.testing.assert_array_equal(result,x*2+1) + assert not graph.has_jit + assert report["interpreter_stages"] > 0 and report["jit_stages"] == 0 + evaluator=blosc2.prepare_evaluate("x+1") + np.testing.assert_array_equal(evaluator({"x":x}),x+1) + blosc2.evaluate("sum(x)",local_dict={"x":x}) + assert blosc2.re_evaluate({"x":x}) == x.sum() + assert blosc2.numexpr is None + if sys.argv[2] != "installed": + assert "numexpr" not in sys.modules + """) + package = {"origin": blosc2.__file__, "paths": list(blosc2.__path__)} + if split_package: + root = Path(__file__).resolve().parents[1] / "src/blosc2" + package = {"origin": str(root / "__init__.py"), "paths": [str(root), *blosc2.__path__]} + result = subprocess.run( + [ + sys.executable, + "-S", + "-c", + source, + json.dumps(sys.path), + "installed" if installed else "absent", + json.dumps(package), + ], + capture_output=True, + text=True, + timeout=60, + ) + assert result.returncode == 0, result.stdout + result.stderr + + +def test_interpreter_bounded_stored_output(native_graph_runtime): + from blosc2.native_graph import _compute_native_stored_output + + values = np.arange(17 * 19, dtype="float64").reshape(17, 19) + inputs = { + "x": blosc2.asarray(values, chunks=(7, 8), blocks=(3, 4)), + "y": np.arange(19, dtype="float64")[None, :], + } + expression = blosc2.lazyexpr("x + y", inputs) + out = blosc2.empty(values.shape, dtype="float64", chunks=(9, 10), blocks=(3, 5)) + result = _compute_native_stored_output(expression, out, {"out": out}, jit=False) + assert result is out + np.testing.assert_array_equal(out[:], values + inputs["y"]) + report = expression._native_execution_report + assert report["backend"] == "portable-interpreter" + assert report["route"] == "bounded-stored-map" + assert report["maximum_input_items"] <= 262144 + + +@pytest.mark.parametrize("legacy", [False, True]) +def test_chunk_evaluator_preserves_caller_scope(legacy): + from blosc2.lazyexpr import evaluate_chunk, ne_evaluate + + x = np.arange(7, dtype="float64") + evaluate = ne_evaluate if legacy else evaluate_chunk + np.testing.assert_array_equal(evaluate("x + 1"), x + 1) + + +@pytest.mark.parametrize("owner", ["blosc2.audit_probe", "external_reference"]) +def test_absence_qualification_detects_swallowed_runtime_imports(monkeypatch, owner): + script = Path(__file__).resolve().parents[1] / "scripts/qualify_without_numexpr.py" + blocker = runpy.run_path(str(script))["BlockNumExpr"]() + monkeypatch.delitem(sys.modules, "numexpr", raising=False) + monkeypatch.setattr(sys, "meta_path", [blocker, *sys.meta_path]) + namespace = {"__name__": owner} + exec("def request():\n import numexpr\n", namespace) + with pytest.raises(ModuleNotFoundError, match="excluded"): + namespace["request"]() + assert blocker.runtime_imports == ([owner] if owner.startswith("blosc2.") else []) + + +def test_external_backend_benchmark_without_numexpr(monkeypatch): + root = Path(__file__).resolve().parents[1] + blocker = runpy.run_path(str(root / "scripts/qualify_without_numexpr.py"))["BlockNumExpr"]() + monkeypatch.delitem(sys.modules, "numexpr", raising=False) + monkeypatch.setattr(sys, "meta_path", [blocker, *sys.meta_path]) + worker = runpy.run_path(str(root / "tools/menudet_backend_bench.py"))["worker"] + result = worker("numpy", "float64", 16, 1) + assert result["warm_median_ns"] > 0 + assert result["numexpr_threads"] is None + assert worker("numexpr", "float64", 16, 1)["status"] == "unavailable" + for tool, args in ( + ("tools/menudet_jit_bench.py", ("numexpr", "affine", "float64", 16, "flat")), + ("tools/menudet_graph_bench.py", (16, "float64", "numexpr", "C", False)), + ): + unavailable = runpy.run_path(str(root / tool))["worker"](*args) + assert unavailable["status"] == "unavailable" + assert not blocker.runtime_imports + + +def test_graph_benchmark_without_resource(monkeypatch): + root = Path(__file__).resolve().parents[1] + worker = runpy.run_path(str(root / "tools/menudet_graph_bench.py"))["worker"] + monkeypatch.setitem(worker.__globals__, "resource", None) + result = worker(16, "float64", "numpy", "C", False) + assert result["warm_median_ms"] > 0 + assert result["peak_rss_bytes"] is None diff --git a/tests/test_objectarray.py b/tests/test_objectarray.py index 53c526c59..616746e80 100644 --- a/tests/test_objectarray.py +++ b/tests/test_objectarray.py @@ -267,9 +267,8 @@ def test_msgpack_supports_lazyudf_dslkernel(tmp_path): oarr = blosc2.ObjectArray() oarr.append(udf) restored = oarr[0] - - assert isinstance(restored, blosc2.LazyUDF) - np.testing.assert_allclose(restored[:], expected) + np.testing.assert_array_equal(restored[:], expected) + assert restored.kernel.schema_version == "1.0" def test_msgpack_rejects_in_memory_lazyexpr(): @@ -284,7 +283,7 @@ def test_msgpack_rejects_plain_python_lazyudf(tmp_path): udf = _make_persistent_python_lazyudf(tmp_path) oarr = blosc2.ObjectArray() - with pytest.raises(TypeError, match="DSLKernel"): + with pytest.raises(TypeError, match="PortableKernel"): oarr.append(udf) diff --git a/tests/test_orthogonal_cases.py b/tests/test_orthogonal_cases.py new file mode 100644 index 000000000..62b40d803 --- /dev/null +++ b/tests/test_orthogonal_cases.py @@ -0,0 +1,22 @@ +"""Keep the default-suite sampling deterministic and preserve every axis value.""" + +from conftest import orthogonal_cases + + +def test_orthogonal_cases_cover_independent_and_mixed_settings(): + dimensions = (["baseline", "other"], [1, 2, 3], [False, True]) + cases = orthogonal_cases(*dimensions) + assert cases == orthogonal_cases(*dimensions) + assert len(cases) == len(set(cases)) < 2 * 3 * 2 + for axis, values in enumerate(dimensions): + assert {case[axis] for case in cases} == set(values) + for value in values: + baseline = [items[0] for items in dimensions] + baseline[axis] = value + assert tuple(baseline) in cases + assert ("other", 2, True) in cases + + +def test_orthogonal_cases_preserve_tuple_axes_and_singletons(): + assert orthogonal_cases([None, (), (0, 2)], [True]) == [(None, True), ((), True), ((0, 2), True)] + assert orthogonal_cases(["only"]) == [("only",)] diff --git a/tests/test_portable_artifact.py b/tests/test_portable_artifact.py new file mode 100644 index 000000000..b00540035 --- /dev/null +++ b/tests/test_portable_artifact.py @@ -0,0 +1,825 @@ +####################################################################### +# Copyright (c) 2026, Blosc Development Team +# SPDX-License-Identifier: BSD-3-Clause +####################################################################### +"""Portable host integration, with separate semantic and execution matrices. + +The exhaustive shared DSL corpus is certified by native miniexpr CTest. Here, +boundary values live in compact dtype/operator scenarios; engine/length checks +are independent. Rejected features do not multiply across unused JIT/size axes. +""" + +import ast +import json +import os +import subprocess +import sys +from pathlib import Path + +import numpy as np +import pytest + +import blosc2 + +SCALE = 2.0 +BIAS = -1.0 + + +@pytest.mark.parametrize("version", ["1.0"]) +@pytest.mark.parametrize("operation", ["sum", "prod", "min", "max", "mean", "any", "all"]) +def test_explicit_block_reduction_names(version, operation): + output = "bool" if operation in {"any", "all"} else "float64" + source = f"def k(x):\n return block_{operation}(x)\n" + artifact = blosc2.DSLKernel.from_source(source).export( + {"x": "float64"}, output, version=version, cardinality="block_scalar" + ) + kernel = blosc2.PortableKernel.from_json(artifact, jit=False) + x = np.array([1.0, 2.0, 3.0]) + np.testing.assert_array_equal(kernel.evaluate({"x": x}), getattr(np, operation)(x)) + with pytest.raises(blosc2.PortableArtifactError): + blosc2.DSLKernel.from_source(f"def k(x):\n return {operation}(x)\n").export( + {"x": "float64"}, output, version=version, cardinality="block_scalar" + ) + + +@pytest.mark.parametrize("version", ["1.0"]) +@pytest.mark.parametrize("dtype", ["bool", "int64", "uint64", "float32", "float64"]) +def test_block_mean_dtype_and_participation(version, dtype): + output = dtype if dtype.startswith("float") else "float64" + artifact = blosc2.DSLKernel.from_source("def k(x):\n return block_mean(x)\n").export( + {"x": dtype}, output, version=version, cardinality="block_scalar" + ) + kernel = blosc2.PortableKernel.from_json(artifact, jit=False) + x = np.array([1, 0, 3], dtype=dtype) + mask = np.array([False, True, True]) + actual = kernel.evaluate_block({"x": x}, valid_mask=mask) + assert actual.dtype == np.dtype(output) + np.testing.assert_array_equal(actual, np.mean(x[mask])) + assert np.isnan(kernel.evaluate_block({"x": x}, valid_mask=np.zeros(3, dtype=bool))) + assert np.isnan(kernel.evaluate_block({"x": x[:0]})) + if dtype in {"int64", "uint64"}: + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block({"x": np.array([np.iinfo(dtype).max, 1], dtype=dtype)}) + + +def assert_execution_mode(kernel, jit): + # Menudet 1.0 may accelerate eligible kernels when explicitly requested. + assert kernel.schema_version == "1.0" + if not jit: + assert not kernel.has_jit + + +@pytest.mark.parametrize( + ("expression", "input_dtype", "output_dtype", "expected"), + [ + ("sin(x)", "float64", "float64", np.sin([-2.0, 0.0, 2.0])), + ("cos(x)", "float32", "float32", np.cos(np.array([-2, 0, 2], dtype="float32"))), + ("int(x + 0.25)", "float64", "int64", [-1, 0, 2]), + ("float(float(x))", "float32", "float32", [-2, 0, 2]), + ("bool((x + 1.0) - x)", "float32", "bool", [True, True, True]), + ("(x + 1.0) > x", "float32", "bool", [True, True, True]), + ("(x / 2) > 0", "float64", "bool", [False, False, True]), + ("x + 0.5", "int64", "int64", [-1, 0, 2]), + ("x == 9007199254740993.0", "int64", "bool", [False, False, False]), + ("float(x)", "int64", "float32", [-2, 0, 2]), + ("float(-(x * 0.1))", "float32", "float32", [0.2, -0.0, -0.2]), + ("bool(int(x + 0.25))", "float64", "bool", [True, False, True]), + ("float(int(x) / 2)", "float32", "float32", [-1, 0, 1]), + ("int(x) / 2", "float64", "int64", [-1, 0, 1]), + ], +) +def test_typed_arithmetic_without_corpus(native_artifacts, expression, input_dtype, output_dtype, expected): + source = f"def k(x):\n return {expression}\n" + assert blosc2.validate_portable_dsl(source, {"x": input_dtype}, output_dtype)["valid"] + artifact = blosc2.DSLKernel.from_source(source).export({"x": input_dtype}, output_dtype) + kernel = blosc2.PortableKernel.from_json(artifact, jit=True) + assert_execution_mode(kernel, True) + actual = kernel.evaluate({"x": np.array([-2, 0, 2], dtype=input_dtype)}) + np.testing.assert_allclose(actual, np.array(expected, dtype=output_dtype), rtol=1e-6) + + +@blosc2.dsl_kernel +def affine(x): + return x * SCALE + BIAS + + +@pytest.fixture +def native_artifacts(): + from blosc2 import blosc2_ext + + available = getattr(blosc2_ext, "portable_artifact_available", lambda: False) + if not available(): + pytest.skip("Rebuild with miniexpr artifact support enabled") + + +def test_prepare_infers_output_without_probe_artifact(native_artifacts): + from blosc2.portable_kernel import prepare_portable_kernel + + kernel = blosc2.DSLKernel.from_source("def k(x):\n return x + 1\n") + prepared = prepare_portable_kernel(kernel, {"x": np.dtype("float32")}, None) + assert prepared.output_dtype == np.dtype("float32") + assert prepared.inferred_dtype == np.dtype("float32") + decoded = json.loads(prepared.to_json()) + assert decoded["output"] == {"contract": "elementwise", "dtype": "float32"} + np.testing.assert_array_equal( + prepared.evaluate({"x": np.arange(4, dtype="float32")}), np.arange(1, 5, dtype="float32") + ) + + +def test_export_capture_snapshot(native_artifacts, monkeypatch): + artifact = affine.export({"x": "float64"}, "float64", metadata={"producer": "test"}) + assert artifact == affine.export({"x": "float64"}, "float64", metadata={"producer": "test"}) + decoded = json.loads(artifact) + assert "SCALE" not in decoded["source"] + assert "BIAS" not in decoded["source"] + assert len(decoded["constants"]) == 2 + monkeypatch.setitem(affine.func.__globals__, "SCALE", 99.0) + monkeypatch.setitem(affine.func.__globals__, "BIAS", 10.0) + kernel = blosc2.PortableKernel.from_json(artifact, jit=False) + x = np.arange(600, dtype=np.float64).reshape(20, 30) + np.testing.assert_array_equal(kernel.evaluate({"x": x}), 2 * x - 1) + assert not kernel.has_jit + assert kernel.entry_point == "affine" + assert kernel.output_dtype == np.dtype("float64") + assert kernel.input_dtypes == {"x": np.dtype("float64")} + assert kernel.to_json() == artifact + with pytest.raises(TypeError): + kernel.input_dtypes["x"] = np.dtype("int64") + + +def test_capture_closure_and_frontend_sugar(native_artifacts): + scale = np.float32(2.0) + + @blosc2.dsl_kernel + def trig(x): + return np.sin(x) * scale + + kernel = blosc2.PortableKernel.from_json(trig.export({"x": "float32"}, "float32"), jit=False) + values = np.array([0, 1, 2], dtype="float32") + np.testing.assert_allclose(kernel.evaluate({"x": values}), np.sin(values) * scale, rtol=1e-6) + + +def test_capture_collision_and_comments(native_artifacts): + scale = 2.0 + + @blosc2.dsl_kernel + def collision(x): + """scale must not be rewritten in strings.""" + _capture_0 = x # scale stays in this comment + return _capture_0 * scale + + artifact = collision.export({"x": "float64"}, "float64") + decoded = json.loads(artifact) + assert decoded["constants"][0]["name"] == "_capture_1" + assert "# scale stays in this comment" in decoded["source"] + assert '"""scale must not be rewritten in strings."""' in decoded["source"] + kernel = blosc2.PortableKernel.from_json(artifact, jit=False) + np.testing.assert_array_equal(kernel.evaluate({"x": np.arange(3, dtype=np.float64)}), [0, 2, 4]) + + +@pytest.mark.parametrize( + ("dtype", "value", "encoding", "encoded"), + [ + ("bool", True, "boolean", True), + ("int32", np.int32(-(2**31)), "decimal", "-2147483648"), + ("int64", 2**63 - 1, "decimal", "9223372036854775807"), + ("float32", np.float32(-0.0), "ieee754-hex", "80000000"), + ("float64", -0.0, "ieee754-hex", "8000000000000000"), + ("float64", np.inf, "ieee754-hex", "7ff0000000000000"), + ("float64", np.nan, "ieee754-hex", "7ff8000000000000"), + ], +) +def test_constant_encodings(native_artifacts, dtype, value, encoding, encoded): + source = "# me:compiler=cc\ndef constant(value):\n return value\n" + author = blosc2.DSLKernel.from_source(source) + artifact = author.export({}, dtype, constants={"value": value}) + scalar = json.loads(artifact)["constants"][0] + assert scalar == { + "name": "value", + "dtype": dtype, + "encoding": encoding, + "value": encoded, + "category": "typed_scalar" if isinstance(value, np.generic) else "weak", + } + kernel = blosc2.PortableKernel.from_json(artifact, jit=False) + assert kernel.source == source + result = kernel.evaluate({}, shape=(600,)) + assert result.dtype == np.dtype(dtype) + np.testing.assert_array_equal(result, np.full(600, value, dtype=dtype)) + if encoded in ("80000000", "8000000000000000"): + assert np.signbit(result).all() + assert kernel.evaluate({}, shape=(0,)).shape == (0,) + with pytest.raises(ValueError, match="explicit shape"): + kernel.evaluate({}) + + +def test_explicit_capture_dtype(native_artifacts): + integer = 2 + + @blosc2.dsl_kernel + def k(x): + return x * integer + + inferred = json.loads(k.export({"x": "float64"}, "float64")) + assert inferred["constants"][0]["dtype"] == "int64" + artifact = k.export({"x": "float64"}, "float64", capture_dtypes={"integer": "float64"}) + np.testing.assert_array_equal( + blosc2.PortableKernel.from_json(artifact, jit=False).evaluate({"x": np.array([3.0])}), [6.0] + ) + with pytest.raises(blosc2.PortableArtifactError, match="Unused capture dtype"): + k.export({"x": "float64"}, "float64", capture_dtypes={"unused": "float64"}) + + +@pytest.mark.parametrize("value", [np.array(2.0), np.arange(2), object(), "hello"]) +def test_capture_value_types(native_artifacts, value): + capture = value + + if type(value) is str: + + @blosc2.dsl_kernel + def string_snapshot(x): + return capture + + artifact = string_snapshot.export({"x": "float64"}, "U5") + constant = json.loads(artifact)["constants"][0] + assert constant["dtype"] == "unicode32" + assert constant["encoding"] == "unicode32be-hex" + np.testing.assert_array_equal( + blosc2.PortableKernel.from_json(artifact).evaluate({"x": np.zeros(2)}), ["hello", "hello"] + ) + return + + @blosc2.dsl_kernel + def k(x): + return x + capture + + with pytest.raises(blosc2.PortableArtifactError, match="Captures"): + k.export({"x": "float64"}, "float64") + + +def test_never_calls_capture_hooks_or_functions(native_artifacts): + class Trap: + def __float__(self): + pytest.fail("capture __float__ executed") + + def item(self): + pytest.fail("capture item executed") + + capture = Trap() + + @blosc2.dsl_kernel + def k(x): + return x + capture + + with pytest.raises(blosc2.PortableArtifactError, match="Captures"): + k.export({"x": "float64"}, "float64", capture_dtypes={"capture": "float64"}) + + def callback(x): + pytest.fail("callback executed") + + @blosc2.dsl_kernel + def external(x): + return callback(x) + + with pytest.raises(blosc2.PortableArtifactError, match="callback"): + external.export({"x": "float64"}, "float64") + + +def test_shadowed_numpy_alias_is_not_rewritten(native_artifacts): + @blosc2.dsl_kernel + def local_alias(x): + np = x + return np.sin(x) + + assert "np.sin" in local_alias.dsl_source + with pytest.raises(blosc2.PortableArtifactError): + local_alias.export({"x": "float64"}, "float64") + + +@pytest.mark.parametrize("jit", [False, None, True]) +def test_artifact_backend_and_repeated_calls(native_artifacts, jit): + from concurrent.futures import ThreadPoolExecutor + + artifact = affine.export({"x": "float64"}, "float64") + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + assert_execution_mode(kernel, jit) + arrays = [np.arange(600, dtype=np.float64) + i for i in range(4)] + if blosc2.IS_WASM: + # Pyodide does not provide Python threads. Keep backend selection and + # repeated-handle coverage without claiming concurrency on that host. + results = [kernel.evaluate({"x": array}) for array in arrays] + else: + with ThreadPoolExecutor(max_workers=4) as executor: + results = list(executor.map(lambda array: kernel.evaluate({"x": array}), arrays)) + for array, result in zip(arrays, results, strict=True): + np.testing.assert_array_equal(result, 2 * array - 1) + + +def test_capture_range_checks(native_artifacts): + kernel = blosc2.DSLKernel.from_source("def k(c):\n return c\n") + for value, dtype in [(2**63, "int64"), (2**31, "int32"), (1e100, "float32")]: + with pytest.raises(blosc2.PortableArtifactError): + kernel.export({}, dtype, constants={"c": value}, capture_dtypes={"c": dtype}) + # Explicit float conversion rounds to nearest, rather than rejecting precision loss. + rounded = kernel.export({}, "float64", constants={"c": 2**53 + 1}, capture_dtypes={"c": "float64"}) + assert blosc2.PortableKernel.from_json(rounded).evaluate({}, shape=())[()] == float(2**53) + + +def test_nan_payload_and_explicit_float_narrowing(native_artifacts): + author = blosc2.DSLKernel.from_source("def k(c):\n return c\n") + value = np.array([0x7FF8000000000042], dtype=np.uint64).view(np.float64)[0] + artifact = author.export({}, "float64", constants={"c": value}) + assert json.loads(artifact)["constants"][0]["value"] == "7ff8000000000042" + value = 1.1 + artifact = author.export({}, "float32", constants={"c": value}, capture_dtypes={"c": "float32"}) + kernel = blosc2.PortableKernel.from_json(artifact, jit=False) + assert kernel.evaluate({}, shape=())[()] == np.float32(value) + + +def test_export_bindings_and_metadata_rejections(native_artifacts): + author = blosc2.DSLKernel.from_source("def k(x):\n return x\n") + with pytest.raises(blosc2.PortableArtifactError, match="exactly one"): + author.export({}, "float64") + with pytest.raises(blosc2.PortableArtifactError, match="exactly one"): + author.export({"x": "float64"}, "float64", constants={"x": 1.0}) + with pytest.raises(blosc2.PortableArtifactError) as error: + author.export({"x": "float64"}, "float64", metadata={"bad": "\x00"}) + assert error.value.status == "invalid_artifact" + with pytest.raises(blosc2.PortableArtifactError) as error: + blosc2.PortableKernel.from_json(b"{\xff}") + assert error.value.status == "invalid_artifact" + with pytest.raises(blosc2.PortableArtifactError) as error: + blosc2.PortableKernel.from_json("{\ud800}") + assert error.value.status == "invalid_artifact" + + +def test_unresolved_capture_has_location(native_artifacts): + @blosc2.dsl_kernel + def k(x): + return x + MISSING_PORTABLE_CAPTURE # noqa: F821 + + with pytest.raises(blosc2.PortableArtifactError) as error: + k.export({"x": "float64"}, "float64") + assert "MISSING_PORTABLE_CAPTURE" in str(error.value) + assert error.value.status == "invalid_source" + assert error.value.line > 0 + assert error.value.column > 0 + + +def test_binding_shapes_and_storage_adaptation(native_artifacts): + source = "def subtract(x, y):\n return x - y\n" + artifact = blosc2.DSLKernel.from_source(source).export({"y": "float64", "x": "float64"}, "float64") + kernel = blosc2.PortableKernel.from_json(artifact, jit=False) + x = np.arange(12, dtype=np.float64).reshape(3, 4)[:, ::2] + y = np.zeros((3, 2), dtype=">f8") + np.testing.assert_array_equal(kernel.evaluate({"y": y, "x": x}), x) + np.testing.assert_array_equal(kernel.evaluate({"y": y, "x": blosc2.asarray(x)}), x) + with pytest.raises(blosc2.PortableArtifactError, match="dtype"): + kernel.evaluate({"x": x.astype(np.float32), "y": y}) + with pytest.raises(blosc2.PortableArtifactError, match="shapes"): + kernel.evaluate({"x": x, "y": y.ravel()}) + with pytest.raises(blosc2.PortableArtifactError, match="Missing or extra"): + kernel.evaluate({"x": x}) + empty = np.empty((0, 3), dtype=np.float64) + assert kernel.evaluate({"y": empty, "x": empty}).shape == (0, 3) + + +def test_import_is_native_only(native_artifacts, monkeypatch): + artifact = affine.export({"x": "float64"}, "float64") + + def forbidden(*args, **kwargs): + pytest.fail("Python source/JSON preparation was invoked") + + with monkeypatch.context() as context: + context.setattr(ast, "parse", forbidden) + context.setattr(json, "loads", forbidden) + kernel = blosc2.PortableKernel.from_json(artifact, jit=False) + result = kernel.evaluate({"x": np.array([0.0, 1.0, 2.0, 3.0])}) + np.testing.assert_array_equal(result, [-1, 1, 3, 5]) + + +def test_export_runs_in_standalone_c(native_artifacts, tmp_path): + runner_path = os.environ.get("MINIEXPR_ARTIFACT_RUNNER") + if not runner_path: + pytest.skip("Set MINIEXPR_ARTIFACT_RUNNER to the standalone native runner") + runner = Path(runner_path) + if not runner.is_file(): + pytest.skip("Set MINIEXPR_ARTIFACT_RUNNER to the standalone native runner") + artifact = tmp_path / "export.json" + artifact.write_text(affine.export({"x": "float64"}, "float64")) + result = subprocess.run([str(runner), str(artifact), "off"], check=True, capture_output=True, text=True) + assert result.stdout.splitlines() == ["jit=0", "-1", "1", "3", "5"] + # A fresh interpreter imports only blosc2, never this authoring test module. + program = "import pathlib, blosc2, numpy as np; " + program += ( + f"k = blosc2.PortableKernel.from_json(pathlib.Path({str(artifact)!r}).read_bytes(), jit=False); " + ) + program += "print(k.evaluate({'x': np.array([0., 1., 2., 3.])}).tolist())" + result = subprocess.run([sys.executable, "-c", program], check=True, capture_output=True, text=True) + assert result.stdout.strip() == "[-1.0, 1.0, 3.0, 5.0]" + + +def test_native_diagnostics_and_runtime_errors(native_artifacts): + artifact = affine.export({"x": "float64"}, "float64") + changed = artifact.replace('"schema_version":"1.0"', '"schema_version":"99"') + with pytest.raises(blosc2.PortableArtifactError) as error: + blosc2.PortableKernel.from_json(changed, jit=False) + assert error.value.status == "unsupported_requirement" + for field in ('"schema_version":"1.0"', '"version":"1.0"'): + with pytest.raises(blosc2.PortableArtifactError, match=r"unsupported.*version"): + blosc2.PortableKernel.from_json(artifact.replace(field, field.replace("1.0", "0.1"))) + retired_manifest = json.loads(artifact) + retired_manifest["schema_version"] = retired_manifest["language"]["version"] = "0.1" + retired_manifest["requires"] = ["core-scalar"] + retired_manifest["output"]["contract"] = "scalar-per-element" + retired_manifest.pop("context") + # Reject the actual retired envelope before applying 1.0's required fields. + with pytest.raises(blosc2.PortableArtifactError, match=r"unsupported.*version"): + blosc2.PortableKernel.from_json(json.dumps(retired_manifest)) + with pytest.raises(blosc2.PortableArtifactError) as retired: + affine.export({"x": "float64"}, "float64", version="0.1") + assert retired.value.status == "unsupported_version" + changed = artifact.replace('"schema_version":', '"schema_version":"0.1","schema_version":') + with pytest.raises(blosc2.PortableArtifactError) as error: + blosc2.PortableKernel.from_json(changed, jit=False) + assert error.value.status == "invalid_artifact" + source = "def partial(x):\n if x > 0:\n return x\n" + artifact = blosc2.DSLKernel.from_source(source).export({"x": "float64"}, "float64") + kernel = blosc2.PortableKernel.from_json(artifact, jit=False) + with pytest.raises(blosc2.PortableArtifactError) as error: + kernel.evaluate({"x": np.array([-1.0])}) + assert error.value.status == "evaluation_error" + assert error.value.native_status != 0 + assert kernel.evaluate({"x": np.empty(0, dtype=np.float64)}).size == 0 + + +def test_import_missing_native_support(monkeypatch): + from blosc2 import blosc2_ext + + monkeypatch.delattr(blosc2_ext, "PortableArtifactHandle", raising=False) + with pytest.raises(NotImplementedError, match="artifact support"): + blosc2.PortableKernel.from_json("{}") + + +def test_optional_adapter_availability(): + from blosc2 import blosc2_ext + + available = getattr(blosc2_ext, "portable_artifact_available", lambda: False)() + if available: + with pytest.raises(blosc2.PortableArtifactError, match="invalid_artifact"): + blosc2.PortableKernel.from_json("{}", jit=False) + else: + with pytest.raises(NotImplementedError, match="artifact support"): + blosc2.PortableKernel.from_json("{}", jit=False) + + +# Execution engines and sizes are independent of the numeric scenario matrix. +# Exercise scalar, short-vector, and tile-tail execution, including repeated +# handles, Boolean bytes, float32 rounding, and local negative zero. +@pytest.mark.parametrize( + ("compiler", "jit"), + [ + pytest.param("tcc", False, id="interpreter"), + pytest.param("tcc", True, id="tcc"), + pytest.param("cc", True, id="cc"), + ], +) +@pytest.mark.parametrize("count", [1, 2, 257]) +def test_numeric_execution_shapes(native_artifacts, compiler, jit, count): + cases = [ + ("bool", "bool", " half = x * 0.5\n return half\n", [True, False], [True, False]), + ( + "float32", + "float32", + " rounded = float(x) + 0.1\n return rounded - float(x)\n", + [2**24, -(2**24)], + [ + np.float32((float(2**24) + 0.1) - float(2**24)), + np.float32((float(-(2**24)) + 0.1) - float(-(2**24))), + ], + ), + ("float64", "float64", " truth = bool(x)\n return -float(truth)\n", [0.0, 1.0], [-0.0, -1.0]), + ] + for input_dtype, output_dtype, body, samples, expected in cases: + source = f"# me:compiler={compiler}\ndef k(x):\n{body}" + artifact = blosc2.DSLKernel.from_source(source).export({"x": input_dtype}, output_dtype) + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + assert_execution_mode(kernel, jit) + for _ in range(2): + actual = kernel.evaluate({"x": np.resize(np.array(samples, dtype=input_dtype), count)}) + desired = np.resize(np.array(expected, dtype=output_dtype), count) + np.testing.assert_array_equal(actual, desired) + if output_dtype == "bool": + assert np.all(actual.view("uint8") <= 1) + else: + np.testing.assert_array_equal(np.signbit(actual), np.signbit(desired)) + + +@pytest.mark.parametrize( + ("body", "samples"), + [ + (" return x + 0.5\n", [True, True]), + (" return x * 0.5\n", [False, True]), + (" return bool(x + 0.5)\n", [True, True]), + (" return (x + x) == 2\n", [False, False]), + (" return (x * 0.5) == 0.5\n", [False, True]), + (" return int(x + 0.5) == 0\n", [True, False]), + (" half = x * 0.5\n return half == 0.5\n", [False, True]), + (" half = x * 0.5\n return half * 2 == x\n", [True, True]), + (" return x - 1\n", [True, False]), + (" return (x + 9007199254740992) - 9007199254740992\n", [False, True]), + ], +) +def test_bool_output_numeric_arithmetic(native_artifacts, body, samples): + compiler, jit, count = "tcc", False, 257 + artifact = blosc2.DSLKernel.from_source(f"# me:compiler={compiler}\ndef k(x):\n{body}").export( + {"x": "bool"}, "bool" + ) + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + assert_execution_mode(kernel, jit) + values = np.resize(np.array([False, True]), count) + expected = np.resize(np.array(samples), count) + for _ in range(2): + actual = kernel.evaluate({"x": values}) + np.testing.assert_array_equal(actual, expected) + assert actual.dtype == np.dtype("bool") + assert np.all(actual.view("uint8") <= 1) + + +# Test each dtype/operation once, rotating the independent execution paths and +# output widths. Backend/length coverage is tested separately below, not crossed +# with every numeric scenario. Locals and direct expressions both remain covered. +@pytest.mark.parametrize( + ("input_dtype", "operation", "compiler", "jit", "output_dtype", "local"), + [ + pytest.param( + dtype, + operation, + "cc" if (d + o) % 3 == 2 else "tcc", + (d + o) % 3 != 0, + "float32" if (d + o) % 2 == 0 else "float64", + (d // 2 + o) % 2 == 1, + id=f"{dtype}-{operation}", + ) + for d, dtype in enumerate(["bool", "int32", "int64", "float32", "float64"]) + for o, operation in enumerate(["sum", "difference", "product", "negation"]) + ], +) +def test_bool_cast_floating_arithmetic( + native_artifacts, compiler, jit, input_dtype, output_dtype, operation, local +): + count = 257 + expressions = { + "sum": "float(bool(x)) + float(bool(x))", + "difference": "float(bool(x)) - float(bool(x))", + "product": "float(bool(x)) * float(bool(x))", + "negation": "-float(bool(x))", + } + expression = expressions[operation] + body = "" + if local: + expression = expression.replace("bool(x)", "truth") + body = " truth = bool(x)\n" + source = f"# me:compiler={compiler}\ndef k(x):\n{body} return {expression}\n" + artifact = blosc2.DSLKernel.from_source(source).export({"x": input_dtype}, output_dtype) + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + assert_execution_mode(kernel, jit) + samples = [0, 1, -1, 2] + if input_dtype == "int64": + samples += [2**53 + 1, -(2**53 + 1)] + elif input_dtype.startswith("float"): + samples += [-0.0, np.finfo(input_dtype).smallest_subnormal, np.inf, -np.inf, np.nan] + values = np.resize(np.array(samples, dtype=input_dtype), count) + truth = (values != 0).astype("float64") + expected = { + "sum": truth + truth, + "difference": truth - truth, + "product": truth * truth, + "negation": -truth, + }[operation].astype(output_dtype) + for _ in range(2): + actual = kernel.evaluate({"x": values}) + np.testing.assert_array_equal(actual, expected) + zeros = expected == 0 + np.testing.assert_array_equal(np.signbit(actual[zeros]), np.signbit(expected[zeros])) + + +@pytest.mark.parametrize("output_dtype", ["float32", "float64"]) +def test_float_cast_arithmetic_rounding(native_artifacts, output_dtype): + compiler, jit, count = "tcc", False, 257 + source = f"# me:compiler={compiler}\ndef k(x):\n return (float(x) + 0.1) - float(x)\n" + artifact = blosc2.DSLKernel.from_source(source).export({"x": "float32"}, output_dtype) + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + assert_execution_mode(kernel, jit) + samples = np.array( + [ + 2**24, + -(2**24), + 0.0, + -0.0, + np.finfo("float32").smallest_subnormal, + np.finfo("float32").max, + np.inf, + -np.inf, + np.nan, + 0.1, + ], + dtype="float32", + ) + values = np.resize(samples, count) + computation = values.astype("float64") + constant = np.float64(0.1) + with np.errstate(all="ignore"): + expected = ((computation + constant) - computation).astype(output_dtype) + for _ in range(2): + actual = kernel.evaluate({"x": values}) + np.testing.assert_array_equal(actual, expected) + zeros = expected == 0 + np.testing.assert_array_equal(np.signbit(actual[zeros]), np.signbit(expected[zeros])) + + +@pytest.mark.parametrize("output_dtype", ["float32", "float64"]) +@pytest.mark.parametrize("operation", ["add", "subtract", "multiply"]) +def test_float_arithmetic_constant_rounding(native_artifacts, output_dtype, operation): + compiler, jit, count = "cc", True, 257 + expressions = { + "add": "(x + 0.1) - x", + "subtract": "x - 0.1", + "multiply": "(x * 0.1) - x", + } + source = f"# me:compiler={compiler}\n# me:fp=strict\ndef k(x):\n return {expressions[operation]}\n" + artifact = blosc2.DSLKernel.from_source(source).export({"x": "float32"}, output_dtype) + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + assert_execution_mode(kernel, jit) + values = np.resize(np.array([0.1, -1, 0, 1, 16777216], dtype="float32"), count) + # Operand-driven float32 computation precedes the output conversion. + arithmetic_values = values + constant = np.array(0.1, dtype="float32") + if operation == "add": + expected = (arithmetic_values + constant) - arithmetic_values + elif operation == "subtract": + expected = arithmetic_values - constant + else: + expected = (arithmetic_values * constant) - arithmetic_values + for _ in range(2): + np.testing.assert_array_equal(kernel.evaluate({"x": values}), expected.astype(output_dtype)) + + +@pytest.mark.parametrize(("compiler", "jit"), [("tcc", False), ("tcc", True), ("cc", True)]) +@pytest.mark.parametrize("cap", ["3", "0", "-1", "invalid"]) +def test_while_cap_policy(native_artifacts, monkeypatch, compiler, jit, cap): + count = 257 + monkeypatch.setenv("ME_DSL_WHILE_MAX_ITERS", cap) + source = f"# me:compiler={compiler}\ndef k(x):\n n = 0\n while n < x:\n n = n + 1\n return n\n" + artifact = blosc2.DSLKernel.from_source(source).export({"x": "int64"}, "int64") + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + assert_execution_mode(kernel, jit) + for target in [0, 2, 3, 4]: + values = np.full(count, target, dtype="int64") + if cap == "3" and target == 4: + with pytest.raises(blosc2.PortableArtifactError) as error: + kernel.evaluate({"x": values}) + assert error.value.status == "evaluation_error" + else: + np.testing.assert_array_equal(kernel.evaluate({"x": values}), values) + # Failed output contents are unspecified; the same prepared handle remains usable. + values = np.full(count, 2, dtype="int64") + np.testing.assert_array_equal(kernel.evaluate({"x": values}), values) + assert kernel.evaluate({"x": np.empty(0, dtype="int64")}).size == 0 + + +@pytest.mark.parametrize(("compiler", "jit"), [("tcc", False), ("tcc", True), ("cc", True)]) +@pytest.mark.parametrize("compile_cap", ["0", "3"]) +def test_while_cap_change_after_loading(native_artifacts, monkeypatch, compiler, jit, compile_cap): + monkeypatch.setenv("ME_DSL_WHILE_MAX_ITERS", compile_cap) + source = f"# me:compiler={compiler}\ndef k(x):\n n = 0\n while n < x:\n n = n + 1\n return n\n" + artifact = blosc2.DSLKernel.from_source(source).export({"x": "int64"}, "int64") + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + assert_execution_mode(kernel, jit) + values = np.array([4], dtype="int64") + monkeypatch.setenv("ME_DSL_WHILE_MAX_ITERS", "2") + with pytest.raises(blosc2.PortableArtifactError, match="evaluation_error"): + kernel.evaluate({"x": values}) + monkeypatch.setenv("ME_DSL_WHILE_MAX_ITERS", "4") + np.testing.assert_array_equal(kernel.evaluate({"x": values}), values) + # The identical source loaded under a different cap must not reuse code + # compiled with the old cap from the shared JIT cache. + new_kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + assert_execution_mode(new_kernel, jit) + np.testing.assert_array_equal(new_kernel.evaluate({"x": values}), values) + monkeypatch.setenv("ME_DSL_WHILE_MAX_ITERS", "3") + with pytest.raises(blosc2.PortableArtifactError, match="evaluation_error"): + kernel.evaluate({"x": values}) + + +@pytest.mark.parametrize( + ("dtype", "compiler", "jit"), + [("int32", "tcc", False), ("int64", "tcc", True), ("float32", "cc", True), ("float64", "tcc", True)], +) +def test_while_chain_mixed_lane(native_artifacts, monkeypatch, compiler, jit, dtype): + monkeypatch.setenv("ME_DSL_WHILE_MAX_ITERS", "3") + source = ( + f"# me:compiler={compiler}\ndef while_cap_chain(x):\n" + " n = 0\n while 0 <= n < x:\n n = n + 1\n return n\n" + ) + artifact = blosc2.DSLKernel.from_source(source).export({"x": dtype}, dtype) + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + assert_execution_mode(kernel, jit) + # Lane ordering is the actual regression boundary, not every size/backend + # combination. Keep both first-lane states in each dtype scenario. + for samples in [[0, 2, 3, -1], [3, 2, 0, -1]]: + values = np.resize(np.array(samples, dtype=dtype), 257) + expected = np.maximum(values, np.array(0, dtype=dtype)) + for _ in range(2): + np.testing.assert_array_equal(kernel.evaluate({"x": values}), expected) + + +@pytest.mark.parametrize( + ("dtype", "compiler", "jit"), + [("int32", "tcc", False), ("int64", "tcc", True), ("float32", "cc", True), ("float64", "tcc", True)], +) +@pytest.mark.parametrize("case", ["masked_local_chain", "masked_bool_chain"]) +def test_masked_local_constant_chain(native_artifacts, compiler, jit, dtype, case): + count = 257 + bodies = { + "masked_local_chain": " n = 0\n if x == 0:\n n = 1\n return 0 <= n < x\n", + "masked_bool_chain": ( + " flag = bool(0)\n if x == 0:\n flag = bool(1)\n" + " return bool(0) <= flag < bool(x)\n" + ), + } + source = f"# me:compiler={compiler}\ndef {case}(x):\n{bodies[case]}" + artifact = blosc2.DSLKernel.from_source(source).export({"x": dtype}, "bool") + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + assert_execution_mode(kernel, jit) + values = np.resize(np.array([0, 1, 2, -1], dtype=dtype), count) + expected = np.resize(np.array([False, True, True, case == "masked_bool_chain"]), count) + for _ in range(2): + np.testing.assert_array_equal(kernel.evaluate({"x": values}), expected) + + +# Cap policy and post-load changes above cover all engines. These scenarios +# isolate control-flow semantics rather than crossing the same policy again. +@pytest.mark.parametrize( + ("body", "expected", "compiler", "jit"), + [ + (" n = 0\n while 0 <= n < 3:\n n = n + 1\n return n\n", 3, "tcc", False), + ( + " n = 0\n while x:\n n = n + 1\n if n == 3:\n break\n return n\n", + 3, + "tcc", + True, + ), + ( + " n = 0\n while x:\n n = n + 1\n if n == 3:\n return n\n return n\n", + 3, + "cc", + True, + ), + ( + " total = 0\n for i in range(2):\n n = 0\n while n < 3:\n" + " n = n + 1\n total = total + 1\n return total\n", + 6, + "tcc", + True, + ), + ( + " total = 0\n n = 0\n while n < 3:\n n = n + 1\n m = 0\n" + " while m < 3:\n m = m + 1\n total = total + 1\n return total\n", + 9, + "cc", + True, + ), + (" if x > 1:\n while x:\n pass\n return x\n", 1, "tcc", False), + ], +) +def test_while_cap_control_flow(native_artifacts, monkeypatch, compiler, jit, body, expected): + monkeypatch.setenv("ME_DSL_WHILE_MAX_ITERS", "3") + artifact = blosc2.DSLKernel.from_source(f"# me:compiler={compiler}\ndef k(x):\n{body}").export( + {"x": "int64"}, "int64" + ) + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + assert_execution_mode(kernel, jit) + np.testing.assert_array_equal( + kernel.evaluate({"x": np.ones(5, dtype="int64")}), np.full(5, expected, dtype="int64") + ) + + +@pytest.mark.parametrize("jit", [False, True]) +@pytest.mark.parametrize("expression", ["int(x)", "bool(x)"]) +def test_value_cast_large_integer(native_artifacts, jit, expression): + source = f"# me:compiler=tcc\ndef k(x):\n return {expression}\n" + output_dtype = "int64" if expression == "int(x)" else "bool" + artifact = blosc2.DSLKernel.from_source(source).export({"x": "int64"}, output_dtype) + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + values = np.array([-(2**53 + 1), 0, 2**53 + 1, 2**63 - 1], dtype="int64") + np.testing.assert_array_equal(kernel.evaluate({"x": values}), values.astype(output_dtype)) + + +@pytest.mark.parametrize("jit", [False, True]) +def test_value_cast_nonfinite_truth(native_artifacts, jit): + source = "# me:compiler=tcc\ndef k(x):\n return bool(x)\n" + artifact = blosc2.DSLKernel.from_source(source).export({"x": "float64"}, "bool") + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + values = np.array([-0.0, 0.0, np.nan, np.inf, -np.inf, 5e-324]) + np.testing.assert_array_equal(kernel.evaluate({"x": values}), values.astype("bool")) diff --git a/tests/test_portable_descriptor.py b/tests/test_portable_descriptor.py new file mode 100644 index 000000000..43ea26b9c --- /dev/null +++ b/tests/test_portable_descriptor.py @@ -0,0 +1,202 @@ +"""Opt-in installed-native descriptor fixtures; never search a sibling checkout.""" + +import json + +import numpy as np +import pytest + +import blosc2 +from blosc2 import blosc2_ext + +pytestmark = pytest.mark.skipif( + not getattr(blosc2_ext, "portable_descriptor_available", lambda: False)(), + reason="Installed native runtime has no draft 1.0 descriptor ABI", +) + + +def manifest(source, inputs, output, *, requires, ndim=0): + return json.dumps( + { + "schema_version": "1.0", + "language": {"name": "miniexpr", "version": "1.0"}, + "requires": requires, + "source": source, + "entry_point": "k", + "inputs": inputs, + "constants": [], + "output": output, + "semantics": {"fp": "strict", "numeric": "numpy-2.5", "casting": "unsafe"}, + "context": {"ndim": ndim}, + "metadata": {"status": "implementation-draft"}, + } + ).encode() + + +def test_descriptor_scalar_mask_empty(): + artifact = blosc2_ext.PortableArtifactHandle( + manifest( + "def k(x):\n return block_sum(x)\n", + [{"name": "x", "dtype": "int64"}], + {"dtype": "int64", "contract": "block_scalar"}, + requires=["numeric", "block-reductions"], + ), + 0, + ) + assert artifact.descriptor_info()["cardinality"] == "block_scalar" + result = artifact.evaluate_block( + {"x": np.array([np.iinfo(np.int64).max, 2, 3])}, + (3,), + valid_mask=np.array([False, True, True]), + ) + assert result.shape == () + assert result == 5 + assert artifact.evaluate_block({"x": np.array([], dtype="int64")}, (0,)) == 0 + assert ( + artifact.evaluate_block( + {"x": np.array([np.iinfo(np.int64).max, 2, 3])}, + (3,), + valid_mask=np.zeros(3, dtype=bool), + ) + == 0 + ) + record = json.loads( + manifest( + "def k(x):\n s = block_sum(x)\n return s\n", + [{"name": "x", "dtype": "int64"}], + {"dtype": "int64", "contract": "block_scalar"}, + requires=["numeric", "block-reductions"], + ) + ) + local = blosc2_ext.PortableArtifactHandle(json.dumps(record).encode(), 0) + assert ( + local.evaluate_block( + {"x": np.array([99, 2, 3], dtype="int64")}, (3,), valid_mask=np.array([False, True, True]) + ) + == 5 + ) + record["output"]["contract"] = "elementwise" + with pytest.raises(ValueError, match="cardinality"): + blosc2_ext.PortableArtifactHandle(json.dumps(record).encode(), 0) + record["output"]["contract"] = "block_scalar" + record["requires"].append("control-flow") + for body in ( + " if x < 0:\n return s + 1\n return s\n", + " for i in range(x):\n return s\n return s + 1\n", + " for i in range(3):\n if x < 0:\n break\n return s + 1\n return s\n", + " for i in range(3):\n if x < 0:\n continue\n return s + 1\n return s\n", + " while block_all(x != 0):\n if x < 0:\n break\n return s + 1\n return s\n", + " if s < 0:\n return s\n elif x < 0:\n return s + 1\n return s\n", + ): + record["source"] = "def k(x):\n s = block_sum(x)\n" + body + with pytest.raises(ValueError, match="ambiguous block-scalar"): + blosc2_ext.PortableArtifactHandle(json.dumps(record).encode(), 0) + for body in ( + " if block_all(x > 0):\n return s + 1\n return s\n", + " for i in range(3):\n if s > 0:\n return s + i\n return s\n", + " for i in range(3):\n if x < 0:\n break\n return s\n", + " while block_all(x > 0):\n return s + 1\n return s\n", + ): + record["source"] = "def k(x):\n s = block_sum(x)\n" + body + coherent = blosc2_ext.PortableArtifactHandle(json.dumps(record).encode(), 0) + assert coherent.evaluate_block({"x": np.array([-1, 2], dtype="int64")}, (2,)) == 1 + + +def test_descriptor_fixed_unicode(): + artifact = blosc2_ext.PortableArtifactHandle( + manifest( + "def k(x):\n return upper(x)\n", + [{"name": "x", "dtype": "unicode32", "itemsize": 16}], + {"dtype": "unicode32", "itemsize": 16, "contract": "elementwise"}, + requires=["numeric", "fixed-strings"], + ), + 0, + ) + result = artifact.evaluate_block({"x": np.array(["ß a"], dtype="U4")}, (1,)) + np.testing.assert_array_equal(result, np.array(["SS A"], dtype="U4")) + record = json.loads( + manifest( + "def k(x):\n return upper(x)\n", + [{"name": "x", "dtype": "unicode32", "itemsize": 16}], + {"dtype": "unicode32", "itemsize": 12, "contract": "elementwise"}, + requires=["numeric", "fixed-strings"], + ) + ) + with pytest.raises(ValueError, match="width"): + blosc2_ext.PortableArtifactHandle(json.dumps(record).encode(), 0) + + +def test_descriptor_logical_coordinates(): + artifact = blosc2_ext.PortableArtifactHandle( + manifest( + "def k():\n return _flat_idx\n", + [], + {"dtype": "int64", "contract": "elementwise"}, + requires=["numeric", "nd-context"], + ndim=2, + ), + 0, + ) + result = artifact.evaluate_block({}, (2, 2), logical_shape=(4, 5), block_origin=(2, 3)) + np.testing.assert_array_equal(result, [[13, 14], [18, 19]]) + with pytest.raises(ValueError, match="Explicit logical"): + artifact.evaluate_block({}, (2, 2)) + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Native prefilter scheduling is unavailable on WASM") +def test_input_free_prefilter_ramp(): + artifact = blosc2_ext.PortableArtifactHandle( + manifest( + "def k():\n return _flat_idx\n", + [], + {"dtype": "int64", "contract": "elementwise"}, + requires=["numeric", "nd-context"], + ndim=1, + ), + 0, + ) + output = blosc2.empty((19,), dtype="int64", chunks=(8,), blocks=(4,)) + assert blosc2_ext.portable_prefilter_inputs_eligible({}, output=output) + result, report = artifact.evaluate_prefilter({}, out=output) + assert result is output + np.testing.assert_array_equal(result[:], np.arange(19)) + assert report["evaluated_blocks"] > 0 + with pytest.raises(NotImplementedError, match="eligible"): + artifact.evaluate_prefilter({}) + + +def test_constructor_ramp_explicit_interpreter(): + from importlib import import_module + + ndarray = import_module("blosc2.ndarray") + lazy = ndarray._menudet_ramp(0, 1, np.dtype("int64"), (19,), execution={"jit": False}) + assert not lazy.kernel.has_jit + np.testing.assert_array_equal(lazy[:], np.arange(19)) + + +@pytest.mark.parametrize( + ("shape", "chunks", "blocks"), + [ + ((11, 13), (6, 8), (4, 3)), + ((9, 11, 13), (5, 6, 8), (3, 4, 3)), + ], +) +@pytest.mark.parametrize("clevel", [0, 5]) +@pytest.mark.parametrize("jit", [0, 1]) +@pytest.mark.skipif(blosc2.IS_WASM, reason="Native prefilter scheduling is unavailable on WASM") +def test_input_free_prefilter_nd_edges(shape, chunks, blocks, clevel, jit): + artifact = blosc2_ext.PortableArtifactHandle( + manifest( + "def k():\n return _flat_idx\n", + [], + {"dtype": "int64", "contract": "elementwise"}, + requires=["numeric", "nd-context"], + ndim=len(shape), + ), + jit, + ) + output = blosc2.empty( + shape, dtype="int64", chunks=chunks, blocks=blocks, cparams={"clevel": clevel, "nthreads": 2} + ) + for _ in range(2): + artifact.evaluate_prefilter({}, out=output) + np.testing.assert_array_equal(output[:], np.arange(np.prod(shape)).reshape(shape)) diff --git a/tests/test_portable_descriptor_host.py b/tests/test_portable_descriptor_host.py new file mode 100644 index 000000000..a580ca18b --- /dev/null +++ b/tests/test_portable_descriptor_host.py @@ -0,0 +1,58 @@ +"""Host routing tests run against the installed pin without a native 1.0 engine.""" + +import numpy as np +import pytest + +from blosc2 import PortableKernel, blosc2_ext + + +def test_native_descriptor_authority_and_block_routing(monkeypatch): + calls = [] + marker = object() + + class Handle: + def __init__(self, record, jit): + assert record == b"opaque record validated only by native code" + + def info(self): + return { + "source": "native source", + "entry_point": "k", + "inputs": {}, + "output_dtype": None, + "jit": False, + } + + def descriptor_info(self): + return { + "schema_version": "1.0", + "inputs": {"x": np.dtype("int64")}, + "output_dtype": np.dtype("int64"), + "cardinality": "block_scalar", + "ndim": 2, + } + + def evaluate_block(self, arrays, shape, **context): + calls.append((arrays, shape, context)) + return marker + + monkeypatch.setattr(blosc2_ext, "PortableArtifactHandle", Handle) + monkeypatch.setattr(blosc2_ext, "portable_descriptor_available", lambda: True, raising=False) + kernel = PortableKernel.from_json(b"opaque record validated only by native code") + assert kernel.result_cardinality == "block_scalar" + assert kernel.context_ndim == 2 + with pytest.raises(ValueError, match="explicit logical_shape"): + kernel.evaluate({"x": np.arange(4, dtype="int64").reshape(2, 2)}) + values = np.arange(8, dtype=">i8").reshape(2, 4)[:, ::2] + mask = np.array([[True, False], [True, True]]) + assert ( + kernel.evaluate_block({"x": values}, logical_shape=(4, 5), block_origin=(2, 3), valid_mask=mask) + is marker + ) + arrays, shape, context = calls[0] + assert shape == (2, 2) + assert arrays["x"].flags.c_contiguous + assert arrays["x"].dtype.isnative + assert context["logical_shape"] == (4, 5) + assert context["block_origin"] == (2, 3) + assert context["valid_mask"] is mask diff --git a/tests/test_portable_jit_integration.py b/tests/test_portable_jit_integration.py new file mode 100644 index 000000000..e9df1d906 --- /dev/null +++ b/tests/test_portable_jit_integration.py @@ -0,0 +1,136 @@ +"""Small production-binding gate; exhaustive lowering parity belongs to miniexpr.""" + +import os + +import numpy as np +import pytest + +import blosc2 + +pytestmark = pytest.mark.usefixtures("native_graph_runtime") + + +def make_kernel(source, signature, output, **kwargs): + artifact = blosc2.DSLKernel.from_source(source).export(signature, output, version="1.0", **kwargs) + kernel = blosc2.PortableKernel.from_json(artifact, jit=True) + if os.environ.get("MENUDET_REQUIRE_JIT") == "1": + assert kernel.has_jit + return kernel + + +def test_capture_binding_roundtrip_and_masked_error_recovery(): + source = "def k(x, c):\n return x + int8(c)\n" + for capture in (1.75, 7.75, 1.75): + kernel = make_kernel(source, {"x": "int8"}, "int8", constants={"c": capture}) + restored = blosc2.PortableKernel.from_json(kernel.to_json(), jit=True) + np.testing.assert_array_equal( + restored.evaluate_block({"x": np.array([0, 1], dtype="int8")}), [int(capture), int(capture) + 1] + ) + kernel = make_kernel("def k(x):\n return int64(x)\n", {"x": "float64"}, "int64") + x = np.array([2.75, np.nan]) + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block({"x": x}) + values = kernel.evaluate_block({"x": x}, valid_mask=np.array([True, False])) + assert values.dtype == np.dtype("int64") + assert values[0] == 2 + np.testing.assert_array_equal(kernel.evaluate_block({"x": np.array([1.0, 2.0])}), [1, 2]) + + +@pytest.mark.parametrize( + ("body", "dtype", "output"), + [ + ("return block_sum(x * 2)", "float32", "float32"), + ("return block_sum(x) + block_prod(x)", "int32", "int64"), + ("return block_mean(x * 2)", "int32", "float64"), + ("s = block_sum(x)\n for i in range(3):\n s = s + i\n return s", "int32", "int64"), + ( + "s = block_mean(x)\n j = 0\n while j < 3:\n j = j + 1\n s = s + 1\n return s", + "float64", + "float64", + ), + ("v = x * 2\n return block_sum(v) + block_mean(v)", "int32", "float64"), + ( + "s = block_sum(x)\n if s > 0:\n return block_mean(x)\n return s", + "float64", + "float64", + ), + ], +) +def test_scalar_partition_dtype_and_status_binding(body, dtype, output): + kernel = make_kernel(f"def k(x):\n {body}\n", {"x": dtype}, output, cardinality="block_scalar") + reference = blosc2.PortableKernel.from_json(kernel.to_json(), jit=False) + x = np.arange(1, 7, dtype=dtype) + for mask in (None, np.arange(6) % 2 == 0, np.zeros(6, dtype=bool)): + actual, status = kernel.evaluate_block({"x": x}, valid_mask=mask, return_status=True) + expected, expected_status = reference.evaluate_block({"x": x}, valid_mask=mask, return_status=True) + assert actual.dtype == np.dtype(output) + np.testing.assert_array_equal(actual, expected) + assert status == expected_status + np.testing.assert_array_equal( + kernel.lazy({"x": x}, partitions=(4,))[:], reference.lazy({"x": x}, partitions=(4,))[:] + ) + + +@pytest.mark.parametrize( + "body", ["return block_mean(float64(_flat_idx))", "v = float64(_flat_idx)\n return block_mean(v)"] +) +def test_logical_context_binding(body): + source = f"def k(x):\n {body}\n" + kernel = make_kernel(source, {"x": "float64"}, "float64", cardinality="block_scalar", ndim=1) + result = kernel.evaluate_block( + {"x": np.ones(3)}, + logical_shape=(8,), + block_shape=(3,), + block_origin=(2,), + valid_mask=np.array([True, False, True]), + ) + assert result == 3 + + +def test_scalar_loop_cap_is_invocation_local(monkeypatch): + source = ( + "def k(x):\n s = block_mean(x)\n j = 0\n" + " while j < 5:\n j = j + 1\n s = s + 1\n return s\n" + ) + kernel = make_kernel(source, {"x": "int64"}, "float64", cardinality="block_scalar") + x = np.array([1, 3], dtype="int64") + monkeypatch.setenv("ME_DSL_WHILE_MAX_ITERS", "2") + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block({"x": x}) + monkeypatch.setenv("ME_DSL_WHILE_MAX_ITERS", "0") + assert kernel.evaluate_block({"x": x}) == 7 + + +def test_system_compiler_binding_smoke(monkeypatch): + if os.name == "nt" or blosc2.IS_WASM: + pytest.skip("System-compiler portable JIT is unsupported on this platform") + monkeypatch.setenv("ME_DSL_JIT_COMPILER", "cc") + kernel = make_kernel("def k(x):\n return x + 1\n", {"x": "float64"}, "float64") + if not kernel.has_jit: + pytest.skip("System compiler unavailable") + values, status = kernel.evaluate_block({"x": np.array([1.0, 2.0])}, return_status=True) + np.testing.assert_array_equal(values, [2, 3]) + assert status["flags"] == 0 + + +def test_tcc_arithmetic_bridge_binding(monkeypatch): + if blosc2.IS_WASM: + pytest.skip("Host arithmetic callbacks are unavailable on WASM") + monkeypatch.setenv("ME_DSL_JIT_COMPILER", "tcc") + x = np.arange(513, dtype=np.float64) + y = np.arange(513, dtype=np.float64) + 1 + kernel = make_kernel( + "def k(x, y):\n return x + (y - 1)\n", + {"x": "float64", "y": "float64"}, + "float64", + ) + if not kernel.has_jit: + pytest.skip("Native TCC JIT unavailable") + expected = x + (y - 1) + actual, status = kernel.evaluate_block({"x": x, "y": y}, return_status=True) + np.testing.assert_array_equal(actual, expected) + assert status["flags"] == 0 + + monkeypatch.setenv("ME_DSL_JIT_ARITH_BRIDGE", "0") + scalar = blosc2.PortableKernel.from_json(kernel.to_json(), jit=True) + np.testing.assert_array_equal(scalar.evaluate_block({"x": x, "y": y}), expected) diff --git a/tests/test_portable_jit_parity.py b/tests/test_portable_jit_parity.py new file mode 100644 index 000000000..9eba5ad1c --- /dev/null +++ b/tests/test_portable_jit_parity.py @@ -0,0 +1,789 @@ +"""Portable JIT parity regressions use the production artifact and graph APIs.""" + +import os +import sys +from concurrent.futures import ThreadPoolExecutor + +import numpy as np +import pytest + +import blosc2 + +pytestmark = [pytest.mark.usefixtures("native_graph_runtime"), pytest.mark.native_semantics] + + +def portable_kernel(source, inputs, output, *, jit=True, constants=None, cardinality="elementwise"): + artifact = blosc2.DSLKernel.from_source(source).export( + inputs, output, constants=constants, version="1.0", cardinality=cardinality + ) + kernel = blosc2.PortableKernel.from_json(artifact, jit=jit) + # Probe backend availability with universally eligible arithmetic. Boolean + # addition itself is not an eligible graph map, although Boolean reductions are. + oracle = blosc2.NativeGraph.from_expression("x + x", {"x": "float64"}, jit=jit) + if jit and os.environ.get("MENUDET_REQUIRE_JIT") == "1": + assert oracle.has_jit, "Requested backend must compile the eligibility oracle" + if oracle.has_jit: + assert kernel.has_jit + return kernel + + +@pytest.mark.parametrize("operator", ["==", "!=", "<", "<=", ">", ">="]) +@pytest.mark.parametrize("mixed", [False, True]) +def test_exact_integer_comparisons(operator, mixed): + signature = {"x": "int64", "y": "uint64" if mixed else "int64"} + source = f"def k(x, y):\n return x {operator} y\n" + kernel = portable_kernel(source, signature, "bool") + reference = portable_kernel(source, signature, "bool", jit=False) + x = np.array([-(2**63), -1, 0, 2**53, 2**63 - 1], dtype="int64") + y = np.array( + [0, 2**64 - 1, 0, 2**53 + 1, 2**64 - 1] if mixed else [-(2**63), 0, -1, 2**53 + 1, 2**63 - 1], + dtype=signature["y"], + ) + actual = kernel.evaluate_block({"x": x, "y": y}) + np.testing.assert_array_equal(actual, reference.evaluate_block({"x": x, "y": y})) + if not mixed and operator == "<": + assert actual[3] + + +def test_checked_weak_intermediate_and_mask_recovery(): + source = "def k(x, y):\n if x == 0:\n return x\n return x + (y + 1)\n" + kernel = portable_kernel(source, {"x": "int64"}, "int64", constants={"y": 2**63 - 1}) + zeros = np.zeros(2, dtype="int64") + np.testing.assert_array_equal(kernel.evaluate_block({"x": zeros}), zeros) + active = np.array([0, 1], dtype="int64") + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block({"x": active}) + kernel.evaluate_block({"x": active}, valid_mask=np.array([True, False])) + np.testing.assert_array_equal(kernel.evaluate_block({"x": zeros}), zeros) + + +@pytest.mark.parametrize("max_iter", [0, 1, 16, 64]) +def test_mandelbrot_portable_jit(max_iter): + # Same per-pixel algorithm as bench/ndarray/jit-dsl-mandelbrot.py. + source = """def k(cr, ci, max_iter): + zr = 0.0 + zi = 0.0 + n = 0 + for _i in range(max_iter): + if zr * zr + zi * zi > 4.0: + break + new_zr = zr * zr - zi * zi + cr + zi = 2 * zr * zi + ci + zr = new_zr + n = n + 1 + return n +""" + signature = {"cr": "float64", "ci": "float64"} + constants = {"max_iter": max_iter} + kernel = portable_kernel(source, signature, "int64", constants=constants) + reference = portable_kernel(source, signature, "int64", constants=constants, jit=False) + cr, ci = np.meshgrid(np.linspace(-2, 1, 31), np.linspace(-1.5, 1.5, 23)) + inputs = {"cr": cr.ravel(), "ci": ci.ravel()} + actual = kernel.evaluate_block(inputs) + expected = reference.evaluate_block(inputs) + np.testing.assert_array_equal(actual, expected) + zr = np.zeros_like(cr) + zi = np.zeros_like(ci) + n = np.zeros(cr.shape, dtype="int64") + active = np.ones(cr.shape, dtype=bool) + for _ in range(max_iter): + active &= zr * zr + zi * zi <= 4.0 + new_zr = zr * zr - zi * zi + cr + new_zi = 2 * zr * zi + ci + zr = np.where(active, new_zr, zr) + zi = np.where(active, new_zi, zi) + n = np.where(active, n + 1, n) + np.testing.assert_array_equal(actual.reshape(cr.shape), n) + restored = blosc2.PortableKernel.from_json(kernel.to_json(), jit=True) + np.testing.assert_array_equal(restored.evaluate_block(inputs), expected) + # Pyodide's single-threaded runtime still qualifies values and round trips. + if sys.platform != "emscripten": + with ThreadPoolExecutor(max_workers=4) as pool: + for result in pool.map(lambda _: kernel.evaluate_block(inputs), range(8)): + np.testing.assert_array_equal(result, expected) + + +def test_while_limit_is_invocation_local(monkeypatch): + monkeypatch.setenv("ME_DSL_WHILE_MAX_ITERS", "3") + kernel = portable_kernel( + "def k(x):\n i = 0\n while i < x:\n i = i + 1\n return i\n", + {"x": "int64"}, + "int64", + ) + values = np.array([0, 3], dtype="int64") + np.testing.assert_array_equal(kernel.evaluate_block({"x": values}), values) + monkeypatch.setenv("ME_DSL_WHILE_MAX_ITERS", "2") + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block({"x": values}) + kernel.evaluate_block({"x": values}, valid_mask=np.array([True, False])) + monkeypatch.setenv("ME_DSL_WHILE_MAX_ITERS", "3") + np.testing.assert_array_equal(kernel.evaluate_block({"x": values}), values) + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("cast", ["int", "int8", "uint8", "int32", "uint32", "int64", "uint64"]) +def test_checked_cast_boundaries(dtype, cast): + output = "int64" if cast == "int" else cast + source = f"def k(x, enabled):\n if enabled:\n return {cast}(x)\n return 0\n" + signature = {"x": dtype, "enabled": "bool"} + kernel = portable_kernel(source, signature, output) + reference = portable_kernel(source, signature, output, jit=False) + limits = np.iinfo(output) + edges = [0, -0.0, 1.75, -1.75, float(limits.min), float(limits.max), np.inf, -np.inf, np.nan] + for value in edges: + x = np.array([1, value], dtype=dtype) + inputs = {"x": x, "enabled": np.ones(2, dtype=bool)} + try: + expected, expected_status = reference.evaluate_block(inputs, return_status=True) + except blosc2.PortableArtifactError: + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block(inputs) + else: + actual, status = kernel.evaluate_block(inputs, return_status=True) + assert actual.tobytes() == expected.tobytes() + assert status == expected_status + kernel.evaluate_block(inputs, valid_mask=np.array([True, False])) + inputs["enabled"][1] = False + assert kernel.evaluate_block(inputs)[1] == 0 + + +@pytest.mark.parametrize("dtype", ["int8", "int32", "int64", "uint64"]) +@pytest.mark.parametrize( + "function", ["abs", "sign", "square", "floor", "ceil", "trunc", "round", "real", "imag", "conj"] +) +def test_integer_builtins(dtype, function): + source = f"def k(x):\n return {function}(x)\n" + kernel = portable_kernel(source, {"x": dtype}, dtype) + reference = portable_kernel(source, {"x": dtype}, dtype, jit=False) + limits = np.iinfo(dtype) + inputs = {"x": np.array([limits.min, 0, 1, limits.max], dtype=dtype)} + actual, status = kernel.evaluate_block(inputs, return_status=True) + expected, reference_status = reference.evaluate_block(inputs, return_status=True) + assert actual.tobytes() == expected.tobytes() + assert status == reference_status + + +@pytest.mark.parametrize("expression", ["fac(x)", "ncr(x, y)", "npr(x, y)", "pow(x, y)", "x ** y"]) +def test_integer_combinatorial_math(expression): + signature = {"x": "int32", "y": "int32"} + source = f"def k(x, y):\n return {expression}\n" + kernel = portable_kernel(source, signature, "int32") + reference = portable_kernel(source, signature, "int32", jit=False) + inputs = {"x": np.array([0, 3, 5], dtype="int32"), "y": np.array([0, 1, 2], dtype="int32")} + assert kernel.evaluate_block(inputs).tobytes() == reference.evaluate_block(inputs).tobytes() + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("expression", ["ldexp(x, 2)", "fma(x, y, -1.0)"]) +def test_multi_operand_math(dtype, expression): + signature = {"x": dtype, "y": dtype} + source = f"def k(x, y):\n return {expression}\n" + kernel = portable_kernel(source, signature, dtype) + reference = portable_kernel(source, signature, dtype, jit=False) + inputs = { + "x": np.array([0, -0.0, 1 + 2**-23, np.inf, np.nan], dtype=dtype), + "y": np.array([1, -1, 1 - 2**-23, 0, 1], dtype=dtype), + } + actual, status = kernel.evaluate_block(inputs, return_status=True) + expected, reference_status = reference.evaluate_block(inputs, return_status=True) + assert actual.tobytes() == expected.tobytes() + assert status == reference_status + + +@pytest.mark.parametrize("capture", [-130, -129, -1, 0, 126, 127, 2**63 - 1]) +def test_computed_weak_capture_checks(capture): + source = "def k(x, c):\n if x == 0:\n return x\n return x + (c + 1)\n" + constants = {"c": capture} + kernel = portable_kernel(source, {"x": "int8"}, "int8", constants=constants) + reference = portable_kernel(source, {"x": "int8"}, "int8", constants=constants, jit=False) + inputs = {"x": np.array([0, 1], dtype="int8")} + try: + expected = reference.evaluate_block(inputs) + except blosc2.PortableArtifactError: + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block(inputs) + else: + assert kernel.evaluate_block(inputs).tobytes() == expected.tobytes() + kernel.evaluate_block(inputs, valid_mask=np.array([True, False])) + np.testing.assert_array_equal(kernel.evaluate_block({"x": np.zeros(2, dtype="int8")}), [0, 0]) + + +@pytest.mark.parametrize("capture", [1.75, -1.75, 127.0, 128.0, np.inf, np.nan]) +def test_floating_weak_capture_conversion(capture): + source = "def k(x, c):\n if x == 0:\n return x\n return x + int8(c)\n" + kernel = portable_kernel(source, {"x": "int8"}, "int8", constants={"c": capture}) + reference = portable_kernel(source, {"x": "int8"}, "int8", constants={"c": capture}, jit=False) + inputs = {"x": np.array([0, 1], dtype="int8")} + try: + expected = reference.evaluate_block(inputs) + except blosc2.PortableArtifactError: + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block(inputs) + else: + assert kernel.evaluate_block(inputs).tobytes() == expected.tobytes() + kernel.evaluate_block(inputs, valid_mask=np.array([True, False])) + + +@pytest.mark.parametrize( + "expression", ["where(x > 0, int(y), 0)", "x > 0 and int(y) > 0", "x <= 0 or int(y) > 0"] +) +def test_checked_expression_short_circuit(expression): + output = "int64" if expression.startswith("where") else "bool" + source = f"def k(x, y):\n return {expression}\n" + signature = {"x": "float64", "y": "float64"} + kernel = portable_kernel(source, signature, output) + reference = portable_kernel(source, signature, output, jit=False) + inputs = {"x": np.array([-1, 1], dtype="float64"), "y": np.array([np.nan, 2], dtype="float64")} + actual, status = kernel.evaluate_block(inputs, return_status=True) + expected, reference_status = reference.evaluate_block(inputs, return_status=True) + assert actual.tobytes() == expected.tobytes() + assert status == reference_status + + +def test_computed_capture_cache_reuse(): + source = "def k(x, c):\n return x + (c + 1)\n" + kernels = [ + (portable_kernel(source, {"x": "int8"}, "int8", constants={"c": value}), value) + for value in (1, 7, -3, 1) + ] + x = np.array([0, 1, 2], dtype="int8") + for kernel, value in reversed(kernels): + np.testing.assert_array_equal(kernel.evaluate_block({"x": x}), x + value + 1) + restored = blosc2.PortableKernel.from_json(kernel.to_json(), jit=True) + np.testing.assert_array_equal(restored.evaluate_block({"x": x}), x + value + 1) + + +@pytest.mark.parametrize("expression", ["c + d", "c - d", "c * d", "-c"]) +@pytest.mark.parametrize( + ("c", "d"), + [ + (2**63 - 1, 1), + (-(2**63), -1), + (2**63 - 1, 2), + (-(2**63), 0), + (0, -(2**63)), + (2**63 - 1, -1), + (-(2**63), 1), + (7, -3), + (0, 0), + ], +) +def test_inline_weak_arithmetic_boundaries(expression, c, d): + source = f"def k(x, c, d):\n if x == 0:\n return x\n return x + ({expression})\n" + constants = {"c": c, "d": d} + kernel = portable_kernel(source, {"x": "int64"}, "int64", constants=constants) + reference = portable_kernel(source, {"x": "int64"}, "int64", constants=constants, jit=False) + inputs = {"x": np.array([0, 1], dtype="int64")} + try: + expected = reference.evaluate_block(inputs) + except blosc2.PortableArtifactError: + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block(inputs) + else: + assert kernel.evaluate_block(inputs).tobytes() == expected.tobytes() + kernel.evaluate_block(inputs, valid_mask=np.array([True, False])) + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("output", ["float32", "float64"]) +@pytest.mark.parametrize( + "expression", + [ + "block_sum(x)", + "block_prod(x)", + "block_sum(x * 2)", + "block_prod(x + y)", + "block_sum(where(x >= 0, x, 0))", + "block_sum(sqrt(x))", + ], +) +def test_serial_floating_reduction_jit(dtype, output, expression): + source = f"def k(x, y):\n return {expression}\n" + signature = {"x": dtype, "y": dtype} + kernel = portable_kernel(source, signature, output, cardinality="block_scalar") + reference = portable_kernel(source, signature, output, jit=False, cardinality="block_scalar") + for values in ([1e16, 1, -1e16, 3], [np.inf, 1, -np.inf, 3], [1, np.nan, 2, 3], [-0.0, 1, 0, 3], []): + x = np.array(values, dtype=dtype) + inputs = {"x": x, "y": x} + for mask in (None, np.arange(x.size) % 2 == 0, np.zeros(x.size, dtype=bool)): + actual, status = kernel.evaluate_block(inputs, valid_mask=mask, return_status=True) + expected, reference_status = reference.evaluate_block( + inputs, valid_mask=mask, return_status=True + ) + # NaN sign/payload propagation is backend-dependent; every other + # result, including signed zero and serial rounding, remains exact. + if not (np.isnan(actual).all() and np.isnan(expected).all()): + assert actual.tobytes() == expected.tobytes() + assert status == reference_status + # The artifact's original partitions remain the reduction boundaries. + x = np.array([1, 2, 3, 4, 5, 6], dtype=dtype) + actual = kernel.lazy({"x": x, "y": x}, partitions=(4,))[:] + expected = reference.lazy({"x": x, "y": x}, partitions=(4,))[:] + np.testing.assert_array_equal(actual, expected) + + +@pytest.mark.parametrize("expression", ["block_sum(x)", "block_prod(x)"]) +def test_checked_integer_reductions_jit(expression): + source = f"def k(x):\n return {expression}\n" + kernel = portable_kernel(source, {"x": "int64"}, "int64", cardinality="block_scalar") + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block({"x": np.array([2**63 - 1, 2], dtype="int64")}) + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("output", ["float32", "float64"]) +@pytest.mark.parametrize( + "body", + [ + "return block_sum(x * 2) / 2", + "return sqrt(block_sum(x))", + "s = block_sum(x)\n return s + 1", + "a = 2.0\n s = block_sum(x * a)\n t = s / a\n return t", + "return block_mean(x)", + "return block_mean(x * 2) / 2", + "s = block_mean(x)\n return s + 1", + "s = block_prod(x + 1)\n return s / 2", + ], +) +def test_scalar_reduction_recipes(dtype, output, body): + source = f"def k(x):\n {body}\n" + kernel = portable_kernel(source, {"x": dtype}, output, cardinality="block_scalar") + reference = portable_kernel(source, {"x": dtype}, output, jit=False, cardinality="block_scalar") + for values in ( + [1e16, 1, -1e16, 3], + [np.inf, 1, -np.inf, 3], + [1, np.nan, 2, 3], + [-0.0, 1, 0, 3], + [np.finfo(dtype).max, 2], + [np.finfo(dtype).tiny, np.finfo(dtype).tiny], + [], + ): + x = np.array(values, dtype=dtype) + for mask in (None, np.arange(x.size) % 2 == 0, np.zeros(x.size, dtype=bool)): + actual, status = kernel.evaluate_block({"x": x}, valid_mask=mask, return_status=True) + expected, expected_status = reference.evaluate_block( + {"x": x}, valid_mask=mask, return_status=True + ) + assert actual.dtype == expected.dtype + if not (np.isnan(actual).all() and np.isnan(expected).all()): + assert actual.tobytes() == expected.tobytes() + assert status == expected_status + x = np.arange(1, 7, dtype=dtype) + np.testing.assert_array_equal( + kernel.lazy({"x": x}, partitions=(4,))[:], reference.lazy({"x": x}, partitions=(4,))[:] + ) + + +@pytest.mark.parametrize("first", [True, False]) +def test_scalar_checked_operand_order_and_recovery(first): + cast = "int64(c)" + reduction = "block_sum(sqrt(x))" + expression = f"{cast} + {reduction}" if first else f"{reduction} + {cast}" + source = f"def k(x, c):\n return {expression}\n" + kernels = [ + portable_kernel( + source, + {"x": "float64"}, + "float64", + jit=jit, + constants={"c": 1e100}, + cardinality="block_scalar", + ) + for jit in (True, False) + ] + errors = [] + for kernel in kernels: + with pytest.raises(blosc2.PortableArtifactError) as failure: + kernel.evaluate_block({"x": np.array([-1.0, 4.0])}) + errors.append(failure.value) + assert errors[0].status == errors[1].status + # Checked status is invocation-local; subsequent calls still report the error. + with pytest.raises(blosc2.PortableArtifactError) as repeated: + kernels[0].evaluate_block({"x": np.array([1.0, 4.0])}) + assert repeated.value.status == errors[0].status + + +@pytest.mark.parametrize("cast", ["int8", "uint8", "int64", "uint64"]) +def test_scalar_final_checked_cast_and_recovery(cast): + source = f"def k(x):\n s = block_sum(x)\n return {cast}(s)\n" + kernel = portable_kernel(source, {"x": "float64"}, cast, cardinality="block_scalar") + reference = portable_kernel(source, {"x": "float64"}, cast, jit=False, cardinality="block_scalar") + for value in (np.nan, np.inf, 1e100): + errors = [] + for k in (kernel, reference): + with pytest.raises(blosc2.PortableArtifactError) as failure: + k.evaluate_block({"x": np.array([value])}) + errors.append(failure.value) + assert errors[0].status == errors[1].status + assert kernel.evaluate_block({"x": np.array([1.75, 2.0])}) == 3 + + +@pytest.mark.parametrize("select", [True, False]) +def test_scalar_lazy_reduction_with_capture(select): + source = "def k(x, select):\n return where(select, block_mean(sqrt(x)), 7.0)\n" + kernel = portable_kernel( + source, {"x": "float64"}, "float64", constants={"select": select}, cardinality="block_scalar" + ) + reference = portable_kernel( + source, + {"x": "float64"}, + "float64", + jit=False, + constants={"select": select}, + cardinality="block_scalar", + ) + for x in (np.array([-1.0, 4.0]), np.array([], dtype="float64")): + for mask in (None, np.zeros(x.size, dtype=bool)): + actual, status = kernel.evaluate_block({"x": x}, valid_mask=mask, return_status=True) + expected, expected_status = reference.evaluate_block( + {"x": x}, valid_mask=mask, return_status=True + ) + np.testing.assert_array_equal(actual, expected) + assert status == expected_status + if not select: + assert actual == 7 + assert status["flags"] == 0 + + +@pytest.mark.parametrize( + "body", + [ + "s = block_sum(x)\n if s > 0:\n v = x\n else:\n v = x * 2\n return block_sum(v)", + "v = x\n for i in range(3):\n v = v * 2\n return block_sum(v)", + ], +) +def test_scalar_recipes_outside_scope_keep_fallback(body): + artifact = blosc2.DSLKernel.from_source(f"def k(x):\n {body}\n").export( + {"x": "float64"}, "float64", version="1.0", cardinality="block_scalar" + ) + assert not blosc2.PortableKernel.from_json(artifact, jit=True).has_jit + + +def test_scalar_mean_logical_context(): + source = "def k(x):\n s = block_mean(float64(_flat_idx))\n return s + 1\n" + artifact = blosc2.DSLKernel.from_source(source).export( + {"x": "float64"}, "float64", version="1.0", cardinality="block_scalar", ndim=1 + ) + kernels = [blosc2.PortableKernel.from_json(artifact, jit=jit) for jit in (True, False)] + oracle = blosc2.NativeGraph.from_expression("x + x", {"x": "float64"}, jit=True) + assert kernels[0].has_jit == oracle.has_jit + for mask in (None, np.array([True, False, True]), np.zeros(3, dtype=bool)): + results = [ + kernel.evaluate_block( + {"x": np.ones(3)}, + block_shape=(3,), + logical_shape=(8,), + block_origin=(2,), + valid_mask=mask, + return_status=True, + ) + for kernel in kernels + ] + np.testing.assert_array_equal(results[0][0], results[1][0]) + assert results[0][1] == results[1][1] + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize( + "body", + [ + "return block_sum(x) / block_sum(x * 2)", + "a = block_sum(x)\n b = block_prod(x)\n return a + b", + "return block_sum(x) + block_sum(x)", + "s = block_sum(x)\n if s > 0:\n return block_mean(x)\n return s", + "s = block_sum(x)\n if s > 0:\n return block_max(x)\n elif s < 0:\n return block_min(x)\n else:\n return s", + "s = block_sum(x)\n if s < 0:\n return s\n else:\n t = block_prod(x)\n return t", + "s = block_sum(x)\n if s > 0:\n t = block_prod(x)\n else:\n t = block_sum(x * 2)\n return t", + "return where(block_sum(x) > 0, block_mean(x), block_sum(x * 2))", + ], +) +def test_multiple_reductions_and_scalar_flow(dtype, body): + source = f"def k(x):\n {body}\n" + kernels = [ + portable_kernel(source, {"x": dtype}, dtype, jit=jit, cardinality="block_scalar") + for jit in (True, False) + ] + for values in ([1, 2, 3], [-1, -2, -3], [0, 0, 0], [np.inf, -np.inf], [np.nan, 1], []): + x = np.array(values, dtype=dtype) + for mask in (None, np.arange(x.size) % 2 == 0, np.zeros(x.size, dtype=bool)): + results, errors = [], [] + for kernel in kernels: + try: + results.append(kernel.evaluate_block({"x": x}, valid_mask=mask, return_status=True)) + except blosc2.PortableArtifactError as error: + errors.append(error.status) + if errors: + assert len(errors) == 2 + assert errors[0] == errors[1] + continue + if not (np.isnan(results[0][0]).all() and np.isnan(results[1][0]).all()): + assert results[0][0].tobytes() == results[1][0].tobytes() + assert results[0][1] == results[1][1] + + +@pytest.mark.parametrize( + "dtype", ["bool", "int8", "uint8", "int16", "uint16", "int32", "uint32", "int64", "uint64"] +) +@pytest.mark.parametrize("op", ["sum", "prod"]) +@pytest.mark.parametrize("mapped", [False, True]) +def test_integer_reduction_recipes(dtype, op, mapped): + operand = "where(x != 0, x, x)" if mapped else "x" + source = f"def k(x):\n s = block_{op}({operand})\n return s\n" + output = "uint64" if dtype.startswith("uint") else "int64" + kernels = [ + portable_kernel(source, {"x": dtype}, output, jit=jit, cardinality="block_scalar") + for jit in (True, False) + ] + cases = [[0, 1, 1], [1, 2, 3], []] + if dtype != "bool": + limits = np.iinfo(dtype) + cases += [[limits.max, 2], [limits.min, -1] if dtype.startswith("int") else [limits.max, 1]] + for values in cases: + x = np.array(values, dtype=dtype) + for mask in (None, np.arange(x.size) % 2 == 0, np.zeros(x.size, dtype=bool)): + results, errors = [], [] + for kernel in kernels: + try: + results.append(kernel.evaluate_block({"x": x}, valid_mask=mask, return_status=True)) + except blosc2.PortableArtifactError as error: + errors.append(error.status) + if errors: + assert len(errors) == 2 + assert errors[0] == errors[1] + else: + assert results[0][0].tobytes() == results[1][0].tobytes() + assert results[0][1] == results[1][1] + for kernel in kernels: + assert kernel.evaluate_block({"x": np.array([1, 1], dtype=dtype)}) == (2 if op == "sum" else 1) + + +@pytest.mark.parametrize("dtype", ["float32", "float64", "uint32", "uint64"]) +def test_checked_range_bounds(dtype): + source = "def k(x):\n s = 0\n for i in range(x):\n s = s + i\n return s\n" + kernels = [portable_kernel(source, {"x": dtype}, "int64", jit=jit) for jit in (True, False)] + x = np.array([0, 1, 3, 4], dtype=dtype) + for kernel in kernels: + np.testing.assert_array_equal(kernel.evaluate_block({"x": x}), [0, 0, 3, 6]) + invalid = ( + [2**63, 2**64 - 1] + if dtype == "uint64" + else ([np.nan, np.inf, -np.inf, float(2**63)] if dtype.startswith("float") else []) + ) + for value in invalid: + for kernel in kernels: + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block({"x": np.array([value], dtype=dtype)}) + np.testing.assert_array_equal(kernel.evaluate_block({"x": x}), [0, 0, 3, 6]) + if dtype.startswith("float"): + for kernel in kernels: + np.testing.assert_array_equal( + kernel.evaluate_block({"x": np.array([3.9, -2.9], dtype=dtype)}), [3, 0] + ) + + +@pytest.mark.parametrize( + "body", + [ + "if x < 0:\n return x\n else:\n y = x + 1\n return y", + "if x < 0:\n return x\n elif x == 0:\n return x\n else:\n y = x + 1\n return y", + "for i in range(2):\n if x < 0:\n continue\n else:\n y = x + 1\n return y\n return x", + ], +) +def test_definite_assignment_at_live_joins(body): + source = f"def k(x):\n {body}\n" + kernels = [portable_kernel(source, {"x": "float64"}, "float64", jit=jit) for jit in (True, False)] + x = np.array([-2.0, 0.0, 3.0]) + results = [kernel.evaluate_block({"x": x}, return_status=True) for kernel in kernels] + np.testing.assert_array_equal(results[0][0], results[1][0]) + assert results[0][1] == results[1][1] + + +def test_scalar_elif_reduction_participation(): + source = ( + "def k(x):\n s = block_sum(x)\n if s > 0:\n return s\n" + " elif block_sum(int64(x * 1e100)) > 0:\n return s\n return s\n" + ) + kernels = [ + portable_kernel(source, {"x": "float64"}, "float64", jit=jit, cardinality="block_scalar") + for jit in (True, False) + ] + for kernel in kernels: + assert kernel.evaluate_block({"x": np.array([1.0, 2.0])}) == 3 + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block({"x": np.array([-1.0, -2.0])}) + assert kernel.evaluate_block({"x": np.array([1.0, 2.0])}) == 3 + + +@pytest.mark.parametrize("op", ["sum", "prod"]) +def test_integer_reduction_modular_map_checked_accumulator(op): + source = f"def k(x):\n return block_{op}(x + 1)\n" + kernels = [ + portable_kernel(source, {"x": "int8"}, "int64", jit=jit, cardinality="block_scalar") + for jit in (True, False) + ] + for kernel in kernels: + assert kernel.evaluate_block({"x": np.array([127, 0], dtype="int8")}) == ( + -127 if op == "sum" else -128 + ) + + +@pytest.mark.parametrize( + "body", + [ + "if x > 0:\n return block_sum(x)\n return block_sum(x)", + "s = block_sum(x)\n for i in range(2):\n s = block_sum(x)\n return s", + ], +) +def test_reductions_in_varying_branches_or_loops_still_rejected(body): + dsl = blosc2.DSLKernel.from_source(f"def k(x):\n {body}\n") + with pytest.raises(blosc2.PortableArtifactError, match="not supported inside"): + dsl.export({"x": "float64"}, "float64", version="1.0", cardinality="block_scalar") + + +@pytest.mark.parametrize("bounds", ["x, 5.0, 1.0", "0.0, 5.0, x", "5.0, 0.0, x"]) +def test_checked_range_start_and_step(bounds): + source = f"def k(x):\n s = 0\n for i in range({bounds}):\n s = s + i\n return s\n" + kernels = [portable_kernel(source, {"x": "float64"}, "int64", jit=jit) for jit in (True, False)] + x = np.array([1.9, -1.9, 2.1]) + np.testing.assert_array_equal(kernels[0].evaluate_block({"x": x}), kernels[1].evaluate_block({"x": x})) + for value in (np.nan, np.inf, 1e100, *([0.9] if bounds.endswith("x") else [])): + for kernel in kernels: + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block({"x": np.array([value])}) + # Nonparticipating invalid bounds never execute conversion/step checks. + kernel.evaluate_block({"x": np.array([value, 1.0])}, valid_mask=np.array([False, True])) + + +def test_explicit_modular_range_cast_remains_explicit(): + source = "def k(x):\n s = 0\n for i in range(int64(x)):\n s = s + i\n return s\n" + for jit in (True, False): + kernel = portable_kernel(source, {"x": "uint64"}, "int64", jit=jit) + assert kernel.evaluate_block({"x": np.array([2**64 - 1], dtype="uint64")}) == 0 + + +def test_possible_empty_loop_local_still_falls_back(): + source = "def k(x):\n for i in range(x):\n y = i\n return y\n" + artifact = blosc2.DSLKernel.from_source(source).export({"x": "int64"}, "int64", version="1.0") + assert not blosc2.PortableKernel.from_json(artifact, jit=True).has_jit + + +@pytest.mark.parametrize( + "dtype", + ["bool", "int8", "uint8", "int16", "uint16", "int32", "uint32", "int64", "uint64", "float32", "float64"], +) +@pytest.mark.parametrize("op", ["min", "max", "any", "all"]) +@pytest.mark.parametrize("mapped", [False, True]) +def test_scalar_extrema_truth_recipes(dtype, op, mapped): + operand = "where(x >= 0, x, x)" if mapped else "x" + source = f"def k(x):\n s = block_{op}({operand})\n return s\n" + output = "bool" if op in ("any", "all") else dtype + kernel = portable_kernel(source, {"x": dtype}, output, cardinality="block_scalar") + reference = portable_kernel(source, {"x": dtype}, output, jit=False, cardinality="block_scalar") + if dtype.startswith("float"): + cases = [[-0.0, 0.0, -0.0], [1, np.nan, 2, -np.nan], [np.inf, -np.inf], [0, 0], []] + snan = np.array([1.0, 0.0, 2.0], dtype=dtype) + snan.view("uint32" if dtype == "float32" else "uint64")[1] = ( + 0x7F800001 if dtype == "float32" else 0x7FF0000000000001 + ) + cases.append(snan) + elif dtype == "bool": + cases = [[False, True, False], [False, False], [True, True], []] + else: + limits = np.iinfo(dtype) + cases = [[limits.min, limits.max, 0], [0, 0], [1, 1], []] + for values in cases: + x = np.array(values, dtype=dtype) + for mask in (None, np.arange(x.size) % 2 == 0, np.zeros(x.size, dtype=bool)): + if op in ("min", "max") and (x.size == 0 or (mask is not None and not mask.any())): + errors = [] + for k in (kernel, reference): + with pytest.raises(blosc2.PortableArtifactError) as failure: + k.evaluate_block({"x": x}, valid_mask=mask) + errors.append(failure.value) + assert errors[0].status == errors[1].status + continue + actual, status = kernel.evaluate_block({"x": x}, valid_mask=mask, return_status=True) + expected, expected_status = reference.evaluate_block( + {"x": x}, valid_mask=mask, return_status=True + ) + assert actual.dtype == expected.dtype + if not (np.isnan(actual).all() and np.isnan(expected).all()): + assert actual.tobytes() == expected.tobytes() + assert status == expected_status + x = np.array([1, 2, 0, 3, 0, 1], dtype=dtype) + np.testing.assert_array_equal( + kernel.lazy({"x": x}, partitions=(4,))[:], reference.lazy({"x": x}, partitions=(4,))[:] + ) + + +@pytest.mark.parametrize(("op", "values"), [("any", [1.0, -1.0]), ("all", [0.0, -1.0])]) +def test_truth_reductions_do_not_skip_late_map_errors(op, values): + source = f"def k(x):\n return block_{op}(int64(x))\n" + kernel = portable_kernel(source, {"x": "float64"}, "bool", cardinality="block_scalar") + reference = portable_kernel(source, {"x": "float64"}, "bool", jit=False, cardinality="block_scalar") + x = np.array([values[0], np.nan]) + for k in (kernel, reference): + with pytest.raises(blosc2.PortableArtifactError): + k.evaluate_block({"x": x}) + assert k.evaluate_block({"x": np.array(values)}) == (op == "any") + + +@pytest.mark.parametrize(("op", "values"), [("any", [1.0, -1.0]), ("all", [0.0, -1.0])]) +def test_truth_reductions_keep_late_fp_status(op, values): + source = f"def k(x):\n return block_{op}(sqrt(x))\n" + kernels = [ + portable_kernel(source, {"x": "float64"}, "bool", jit=jit, cardinality="block_scalar") + for jit in (True, False) + ] + results = [k.evaluate_block({"x": np.array(values)}, return_status=True) for k in kernels] + np.testing.assert_array_equal(results[0][0], results[1][0]) + assert results[0][1] == results[1][1] + if sys.platform != "emscripten": + assert results[0][1]["flags"] & 1 + + +@pytest.mark.parametrize("op", ["min", "max"]) +def test_lazy_extrema_do_not_raise_for_unselected_empty_group(op): + source = f"def k(x, select):\n return where(select, block_{op}(x), 7.0)\n" + for jit in (True, False): + kernel = portable_kernel( + source, + {"x": "float64"}, + "float64", + jit=jit, + constants={"select": False}, + cardinality="block_scalar", + ) + result, status = kernel.evaluate_block({"x": np.array([], dtype="float64")}, return_status=True) + assert result == 7 + assert not status["flags"] + + +@pytest.mark.parametrize("op", ["min", "max", "any", "all"]) +@pytest.mark.parametrize("capture", [0.0, -2.0]) +def test_extrema_truth_uniform_capture(op, capture): + source = f"def k(x, c):\n return block_{op}(c)\n" + output = "bool" if op in ("any", "all") else "float64" + kernels = [ + portable_kernel( + source, + {"x": "float64"}, + output, + jit=jit, + constants={"c": capture}, + cardinality="block_scalar", + ) + for jit in (True, False) + ] + for mask in (None, np.array([True, False, True]), np.zeros(3, dtype=bool)): + if op in ("min", "max") and mask is not None and not mask.any(): + for kernel in kernels: + with pytest.raises(blosc2.PortableArtifactError): + kernel.evaluate_block({"x": np.ones(3)}, valid_mask=mask) + continue + results = [ + kernel.evaluate_block({"x": np.ones(3)}, valid_mask=mask, return_status=True) + for kernel in kernels + ] + np.testing.assert_array_equal(results[0][0], results[1][0]) + assert results[0][1] == results[1][1] diff --git a/tests/test_portable_lazy.py b/tests/test_portable_lazy.py new file mode 100644 index 000000000..70b6b87eb --- /dev/null +++ b/tests/test_portable_lazy.py @@ -0,0 +1,268 @@ +import gc +import weakref + +import numpy as np +import pytest +from test_portable_descriptor import manifest + +import blosc2 +from blosc2 import blosc2_ext + +pytestmark = pytest.mark.skipif( + not getattr(blosc2_ext, "portable_descriptor_available", lambda: False)(), + reason="Installed runtime has no draft descriptor ABI", +) + + +def kernel(source, *, scalar=False, nd=False, string=False): + dtype = "unicode32" if string else "int64" + inputs = [{"name": "x", "dtype": dtype}] + output = {"dtype": dtype, "contract": "block_scalar" if scalar else "elementwise"} + requires = ["numeric"] + if string: + inputs[0]["itemsize"] = output["itemsize"] = 16 + requires.append("fixed-strings") + if scalar: + requires.append("block-reductions") + if nd: + requires.append("nd-context") + return blosc2.PortableKernel.from_json( + manifest(source, inputs, output, requires=requires, ndim=2 if nd else 0), jit=False + ) + + +@pytest.mark.parametrize("scalar", [False, True]) +def test_safe_graph_native_partition_buffers_release_without_cyclic_gc(monkeypatch, scalar): + native = kernel( + "def k(x):\n return block_sum(x)\n" if scalar else "def k(x):\n return x + 1\n", scalar=scalar + ) + data = np.arange(4096, dtype="int64") + source = blosc2.asarray(data, chunks=(128,), blocks=(32,)) + lazy = native.lazy({"x": source}, partitions=(128,)) + refs, extents = [], [] + original = blosc2.PortableKernel.evaluate_block + + def evaluate(self, operands, **kwargs): + if self is native: + assert kwargs["block_shape"] == (128,) + assert operands["x"].nbytes <= 128 * data.dtype.itemsize + refs.append(weakref.ref(operands["x"])) + extents.append(kwargs["block_shape"]) + result = original(self, operands, **kwargs) + if self is native: + refs.append(weakref.ref(result)) + return result + + monkeypatch.setattr(blosc2.PortableKernel, "evaluate_block", evaluate) + # Lane-local recipes may use native readers instead of materializing groups. + # Keep the same lifetime/memory assertions for both execution routes. + from blosc2.storage_readers import StorageReader + + original_read = StorageReader.read + original_sources = blosc2.PortableKernel.evaluate_sources + + def read(self, indices): + result = original_read(self, indices) + if self.value is source: + assert result.nbytes <= 128 * data.dtype.itemsize + refs.append(weakref.ref(result)) + extents.append(result.shape) + return result + + def evaluate_sources(self, *args, **kwargs): + result = original_sources(self, *args, **kwargs) + if self is native: + refs.append(weakref.ref(result[0] if kwargs.get("return_report") else result)) + return result + + monkeypatch.setattr(StorageReader, "read", read) + monkeypatch.setattr(blosc2.PortableKernel, "evaluate_sources", evaluate_sources) + expr = blosc2.lazyexpr("x + 2", {"x": lazy}, evaluation="safe") + expected = data.reshape(-1, 128).sum(axis=1) + 2 if scalar else data + 3 + enabled = gc.isenabled() + gc.disable() + try: + for _ in range(4): + np.testing.assert_array_equal(expr[2:5], expected[2:5]) + assert extents + assert all(ref() is None for ref in refs) + finally: + if enabled: + gc.enable() + + +@pytest.mark.parametrize("mutation", ["kernel", "handle", "metadata", "artifact", "native_rebinding"]) +def test_safe_graph_checks_portable_kernel_closure_before_hooks(monkeypatch, mutation): + native = kernel("def k(x):\n return x + 1\n") + lazy = native.lazy({"x": blosc2.asarray(np.arange(4, dtype="int64"))}) + expr = blosc2.lazyexpr("x + 1", {"x": lazy}, evaluation="safe") + np.testing.assert_array_equal(expr[:], np.arange(4) + 2) + + class Hostile: + @property + def output_dtype(self): + pytest.fail("Read hostile portable output dtype") + + def __eq__(self, other): + pytest.fail("Compared hostile portable metadata") + + if mutation == "kernel": + monkeypatch.setattr(lazy, "kernel", Hostile()) + elif mutation == "handle": + monkeypatch.setattr(native, "_handle", Hostile()) + elif mutation == "metadata": + monkeypatch.setitem(native._info, "output_dtype", Hostile()) + elif mutation == "artifact": + monkeypatch.setattr(native, "_artifact", b"{}") + else: + other = kernel("def k(x):\n return x + 2\n") + monkeypatch.setattr(native, "_handle", other._handle) + with pytest.raises((blosc2.UnsafeDeserializationError, ValueError)): + expr.compute() + + +@pytest.mark.parametrize("mutation", ["mapping", "domain", "partitions", "shape", "grid", "input_dtype"]) +def test_safe_graph_checks_portable_domain_and_binding_metadata(monkeypatch, mutation): + lazy = kernel("def k(x):\n return x + 1\n").lazy( + {"x": blosc2.asarray(np.arange(4, dtype="int64"))}, partitions=(2,) + ) + expr = blosc2.lazyexpr("x + 1", {"x": lazy}, evaluation="safe") + + class HostileMapping: + def values(self): + pytest.fail("Read hostile portable input mapping") + + if mutation == "mapping": + monkeypatch.setattr(lazy, "inputs", HostileMapping()) + elif mutation == "domain": + monkeypatch.setattr(lazy, "_domain", (object(),)) + elif mutation == "partitions": + monkeypatch.setattr(lazy, "_partitions", (0,)) + elif mutation == "shape": + monkeypatch.setattr(lazy, "_shape", (5,)) + elif mutation == "grid": + monkeypatch.setattr(lazy, "_grid", (5,)) + else: + monkeypatch.setitem(lazy.inputs, "x", blosc2.asarray(np.arange(4, dtype="float64"))) + with pytest.raises((blosc2.UnsafeDeserializationError, ValueError)): + expr.compute() + + +@pytest.mark.parametrize("scalar", [False, True]) +def test_logical_groups_partial_and_rechunk(tmp_path, scalar): + values = np.arange(35, dtype="int64").reshape(5, 7) + stored = blosc2.asarray(values, chunks=(3, 4), blocks=(1, 2), urlpath=tmp_path / "input.b2nd") + k = kernel( + "def k(x):\n return block_sum(x)\n" if scalar else "def k(x):\n return x + _flat_idx\n", + scalar=scalar, + nd=not scalar, + ) + lazy = k.lazy({"x": stored}, partitions=(2, 3)) + expected = ( + np.array([[values[i : i + 2, j : j + 3].sum() for j in range(0, 7, 3)] for i in range(0, 5, 2)]) + if scalar + else values * 2 + ) + assert lazy.partitions == (2, 3) + np.testing.assert_array_equal(lazy[:], expected) + np.testing.assert_array_equal(lazy[1:, ::2], expected[1:, ::2]) + np.testing.assert_array_equal( + lazy.compute(item=(slice(1, None), slice(None, None, 2)))[:], expected[1:, ::2] + ) + np.testing.assert_array_equal(lazy.rechunk(chunks=(1, 2), blocks=(1, 1))[:], expected) + path = tmp_path / "lazy.b2nd" + lazy.save(path) + reopened = blosc2.open(path) + assert reopened.partitions == (2, 3) + np.testing.assert_array_equal(reopened[:], expected) + mixed = lazy + 3 + mixed.save(tmp_path / "mixed.b2nd") + np.testing.assert_array_equal(blosc2.open(tmp_path / "mixed.b2nd")[:], expected + 3) + + +def test_string_roundtrip_and_native_only_load(tmp_path, monkeypatch): + values = np.array(["ß a", "ab", "z"], dtype="U4") + stored = blosc2.asarray(values, urlpath=tmp_path / "text.b2nd") + lazy = kernel("def k(x):\n return upper(x)\n", string=True).lazy({"x": stored}, partitions=(2,)) + lazy.save(tmp_path / "textlazy.b2nd") + import importlib + + dsl_module = importlib.import_module("blosc2.dsl_kernel") + monkeypatch.setattr( + dsl_module, "kernel_from_source", lambda *a, **k: pytest.fail("Python reconstruction") + ) + import blosc2.b2objects as b2objects + + monkeypatch.setattr( + b2objects, "kernel_from_source", lambda *a, **k: pytest.fail("Python reconstruction") + ) + np.testing.assert_array_equal(blosc2.open(tmp_path / "textlazy.b2nd")[:], ["SS A", "AB", "Z"]) + + +def test_preflight_preserves_destination(tmp_path): + lazy = kernel("def k(x):\n return x + 1\n").lazy({"x": np.arange(3, dtype="int64")}) + path = tmp_path / "existing" + path.write_bytes(b"sentinel") + with pytest.raises((TypeError, ValueError)): + lazy.save(path) + assert path.read_bytes() == b"sentinel" + + +@pytest.mark.parametrize("route", ["frame", "msgpack", "embed", "dict", "tree"]) +def test_container_routes(tmp_path, route): + from blosc2.msgpack_utils import msgpack_packb, msgpack_unpackb + + source = blosc2.asarray(np.arange(9, dtype="int64"), urlpath=tmp_path / "source.b2nd") + lazy = kernel("def k(x):\n return block_sum(x)\n", scalar=True).lazy({"x": source}, partitions=(4,)) + expected = np.array([6, 22, 8]) + if route == "frame": + reopened = blosc2.from_cframe(lazy.to_cframe()) + elif route == "msgpack": + reopened = msgpack_unpackb(msgpack_packb(lazy), deserialize="safe") + else: + cls = {"embed": blosc2.EmbedStore, "dict": blosc2.DictStore, "tree": blosc2.TreeStore}[route] + with cls(str(tmp_path / "store.b2z"), mode="w") as store: + store["/lazy"] = lazy + reopened = store["/lazy"] + np.testing.assert_array_equal(reopened[:], expected) + with cls(str(tmp_path / "store.b2z"), mode="r") as store: + reopened = store["/lazy"] + np.testing.assert_array_equal(reopened[:], expected) + return + np.testing.assert_array_equal(reopened[:], expected) + + +def test_partial_reads_only_original_groups(): + class Operand: + dtype = np.dtype("int64") + shape = (12,) + + def __init__(self): + self.reads = [] + + def __getitem__(self, item): + self.reads.append(item) + return np.arange(12, dtype="int64")[item] + + operand = Operand() + lazy = kernel("def k(x):\n return block_sum(x)\n", scalar=True).lazy({"x": operand}, partitions=(4,)) + np.testing.assert_array_equal(lazy[1:2], [22]) + assert operand.reads == [(slice(4, 8),)] + assert lazy[1] == 22 + np.testing.assert_array_equal(lazy[::-1], [38, 22, 6]) + author = blosc2.DSLKernel.from_source("def k(x):\n return x + block_sum(x)\n") + elementwise = blosc2.PortableKernel.from_json(author.export({"x": "int64"}, "int64", version="1.0")) + grouped = elementwise.lazy({"x": operand}, partitions=(4,)) + operand.reads.clear() + np.testing.assert_array_equal(grouped[7:3:-2], [29, 27]) + assert operand.reads == [(slice(4, 8),)] + np.testing.assert_array_equal(grouped[4:4], np.array([], dtype="int64")) + assert operand.reads == [(slice(4, 8),)] + + +def test_broadcast_coordinates_keep_output_domain(): + values = np.arange(7, dtype="int64").reshape(1, 7) + k = kernel("def k(x):\n return x + _flat_idx\n", nd=True) + lazy = k.lazy({"x": values}, shape=(5, 7), partitions=(2, 3)) + expected = values + np.arange(35).reshape(5, 7) + np.testing.assert_array_equal(lazy[3:, 4:], expected[3:, 4:]) diff --git a/tests/test_portable_policy.py b/tests/test_portable_policy.py new file mode 100644 index 000000000..8df12dba7 --- /dev/null +++ b/tests/test_portable_policy.py @@ -0,0 +1,155 @@ +"""Metadata policy/preflight checks independent of the installed native version.""" + +from pathlib import Path + +import numpy as np +import pytest + +import blosc2 +from blosc2.b2objects import decode_b2object_payload + + +@pytest.mark.parametrize("policy", ["safe", "full"]) +@pytest.mark.parametrize("expression", ["x + 1", "sqrt(x)"]) +def test_nested_legacy_effective_policy(tmp_path, policy, expression): + fixture = Path(__file__).parent / "data" / "legacy_lazyudf_v1" / "expr.b2nd" + carrier = blosc2.empty((5,), dtype="float64", meta={"b2o": {"kind": "lazyexpr", "version": 1}}) + carrier.schunk.vlmeta["b2o"] = { + "kind": "lazyexpr", + "version": 1, + "expression": expression, + "operands": {"x": {"kind": "urlpath", "version": 1, "urlpath": str(fixture)}}, + } + if policy == "safe": + with pytest.raises(blosc2.UnsafeDeserializationError): + blosc2.from_cframe(carrier.to_cframe(), deserialize=policy) + else: + opened = blosc2.from_cframe(carrier.to_cframe(), deserialize=policy) + nested = next(iter(opened.operands.values())) + assert isinstance(nested, blosc2.LazyUDF) + np.testing.assert_allclose(nested.compute()[:], (np.arange(5) * 3) ** 2) + + +def test_structured_legacy_rejects_before_python(monkeypatch): + from msgpack import ExtType, packb + + import blosc2.b2objects as b2objects + from blosc2.msgpack_utils import msgpack_unpackb + + record = { + "kind": "lazyudf", + "version": 1, + "function_kind": "dsl", + "dsl_version": 1, + "udf_source": "def k():\n return 1\n", + "name": "k", + "dtype": "int64", + "shape": [2], + "operands": {}, + "kwargs": {}, + } + legacy = ExtType(43, packb(record)) + nested = ExtType(46, packb({"values": [legacy], "shape": [1]})) + for payload in (packb(legacy), packb(nested)): + trusted = msgpack_unpackb(payload, deserialize="full") + assert isinstance(trusted if isinstance(trusted, blosc2.LazyUDF) else trusted[0], blosc2.LazyUDF) + legacy_recipe = trusted if isinstance(trusted, blosc2.LazyUDF) else trusted[0] + with pytest.raises(TypeError, match="legacy"): + legacy_recipe.to_cframe() + + monkeypatch.setattr(b2objects, "kernel_from_source", lambda *a, **k: pytest.fail("Policy bypass")) + with pytest.raises(blosc2.UnsafeDeserializationError): + decode_b2object_payload({"kind": "lazyudf", "version": 1}, deserialize="safe") + for payload in (packb(legacy), packb(nested)): + with pytest.raises(blosc2.UnsafeDeserializationError): + msgpack_unpackb(payload) + with pytest.raises(blosc2.UnsafeDeserializationError): + msgpack_unpackb(payload, deserialize="safe") + + +@pytest.mark.parametrize("route", ["embed", "dict", "tree"]) +def test_rejected_kernel_does_not_replace_store_value(tmp_path, route): + cls = {"embed": blosc2.EmbedStore, "dict": blosc2.DictStore, "tree": blosc2.TreeStore}[route] + udf = blosc2.lazyudf(lambda inputs, output, offset: None, (np.arange(4),), dtype="int64") + with cls(str(tmp_path / "store.b2z"), mode="w") as store: + store["/value"] = np.arange(4) + with pytest.raises(TypeError, match="PortableKernel"): + store["/value"] = udf + np.testing.assert_array_equal(store["/value"][:], np.arange(4)) + operand = blosc2.asarray(np.arange(4), urlpath=tmp_path / "input.b2nd", mode="w") + for body in ("print(x)\n return x", "return callback(x)"): + kernel = blosc2.DSLKernel.from_source(f"def invalid(x):\n {body}\n") + invalid = blosc2.lazyudf(kernel, (operand,), dtype="int64") + with pytest.raises(blosc2.PortableArtifactError): + store["/value"] = invalid + np.testing.assert_array_equal(store["/value"][:], np.arange(4)) + valid = blosc2.DSLKernel.from_source("def valid(x):\n return x + 2\n") + store["/recipe"] = blosc2.lazyudf(valid, (operand,), dtype="int64") + np.testing.assert_array_equal(store["/recipe"][:], np.arange(4) + 2) + + +def test_ctable_legacy_metadata_policy_before_reconstruction(monkeypatch): + from types import SimpleNamespace + + table = object.__new__(blosc2.CTable) + table._storage = SimpleNamespace(_deserialize_mode="safe") + schema = { + "computed_columns": [ + {"name": "bad", "col_deps": [], "dtype": "int64", "kind": "dsl", "dsl_source": "invalid"} + ] + } + with pytest.raises( + blosc2.UnsafeDeserializationError, match=r"block/batch-dependent.*deserialize='full'" + ): + table._load_computed_cols_from_schema(schema) + table._computed_cols = {"x": {"kind": "dsl"}} + table._materialized_cols = {} + with pytest.raises(TypeError, match="row-domain"): + table._preflight_portable_persistence() + + +@pytest.mark.parametrize("generated", [False, True]) +def test_legacy_table_recipes_retain_full_opt_in(tmp_path, generated): + from dataclasses import dataclass + + @dataclass + class Row: + x: float = 0.0 + + path = str(tmp_path / "legacy.b2d") + table = blosc2.CTable( + Row, urlpath=path, mode="w", new_data={"x": [2.0, 4.0]}, create_summary_index=False + ) + if generated: + table.add_column("old", blosc2.float64(), values=np.array([4.0, 6.0])) + schema = table._schema_dict_with_computed() + recipe = { + "name": "old", + "dsl_source": "def old(x):\n return x + sum(x)\n", + "col_deps": ["x"], + "dtype": "float64", + } + if generated: + recipe.update(transformer_kind="dsl", stale=False, computed_column=None, expression=None) + schema["materialized_columns"] = [recipe] + else: + recipe["kind"] = "dsl" + schema["computed_columns"] = [recipe] + table._storage.save_schema(schema) + table.close() + with pytest.raises( + blosc2.UnsafeDeserializationError, match=r"block/batch-dependent.*deserialize='full'" + ): + blosc2.CTable.open(path) + trusted = blosc2.CTable.open(path, mode="a", deserialize="full") + if generated: + expected_batch = trusted._evaluate_dsl_materialized_batch( + trusted._materialized_cols["old"], {"x": np.array([8.0])} + ) + trusted.append({"x": 8.0}) + # Appended batches retain their old groups rather than adopting the new API contract. + np.testing.assert_array_equal(trusted["old"][:], [4.0, 6.0, expected_batch[0]]) + else: + # The original two-row execution block, not independent one-lane rows. + np.testing.assert_array_equal(trusted["old"][:], [8.0, 10.0]) + trusted.close() diff --git a/tests/test_portable_table_export.py b/tests/test_portable_table_export.py new file mode 100644 index 000000000..3567bc407 --- /dev/null +++ b/tests/test_portable_table_export.py @@ -0,0 +1,259 @@ +import importlib +from dataclasses import dataclass + +import numpy as np +import pytest + +import blosc2 +from blosc2 import blosc2_ext + +pytestmark = pytest.mark.skipif( + not getattr(blosc2_ext, "portable_descriptor_available", lambda: False)(), + reason="Installed runtime has no draft descriptor ABI", +) + + +def test_authoring_typed_snapshots(monkeypatch, tmp_path): + validate = blosc2.validate_portable_dsl + with monkeypatch.context() as guard: + guard.setattr( + blosc2_ext, "PortableArtifactHandle", lambda *a: pytest.fail("Artifact loader invoked") + ) + cache = tmp_path / "validation-jit-cache" + guard.setenv("CC", "/no/compiler") + guard.setenv("ME_DSL_JIT_COMPILER", "cc") + guard.setenv("ME_DSL_JIT", "1") + guard.setenv("ME_DSL_JIT_CACHE_DIR", str(cache)) + assert validate( + "# me:compiler=cc\ndef k(x):\n while 1:\n pass\n return x\n", + {"x": "float32"}, + "float32", + language_version="1.0", + )["valid"] + assert validate( + "# me:compiler=cc\ndef k(x, y):\n return sin(x) + y\n", + {"y": "int16", "x": "float32"}, + "float32", + language_version="1.0", + )["valid"] + assert validate("def k(x):\n return upper(x)\n", {"x": "U4"}, "U4", language_version="1.0")[ + "valid" + ] + assert validate("def k(x):\n return x\n", {"x": ">S4"}, "S4", language_version="1.0")["valid"] + assert not validate("def k(x):\n return upper(x)\n", {"x": "U4"}, "U3", language_version="1.0")[ + "valid" + ] + scalar = "def k(x):\n return block_sum(x)\n" + assert validate(scalar, {"x": "int16"}, "int64", language_version="1.0", cardinality="block_scalar")[ + "valid" + ] + assert ( + validate(scalar, {"x": "int16"}, "int64", language_version="1.0", cardinality="elementwise")[ + "status" + ] + == "invalid_signature" + ) + nd = "def k(x):\n return x + _i1\n" + missing = validate(nd, {"x": "int64"}, "int64", language_version="1.0") + assert not missing["valid"] + assert "rank" in missing["error"] + assert validate(nd, {"x": "int64"}, "int64", language_version="1.0", ndim=2)["valid"] + pair = {"x": "int64", "y": "uint64"} + assert validate("def k(x, y):\n return x < y\n", pair, "bool", language_version="1.0")["valid"] + assert validate("def k(x, y):\n return x + y\n", pair, "float64", language_version="1.0")["valid"] + for body in ("print(x)\n return x", "return callback(x)", "return x & 1"): + rejected = validate( + f"def k(x):\n {body}\n", {"x": "float32"}, "float32", language_version="1.0" + ) + assert not rejected["valid"] + assert rejected["line"] == 2 + assert rejected["column"] > 0 + invalid = validate("def k(x):\n return (\n", {"x": "float32"}, "float32", language_version="1.0") + assert invalid["status"] == "invalid_source" + assert invalid["line"] > 0 + assert invalid["column"] > 0 + assert not cache.exists() + + offset = np.uint64(7) + + @blosc2.dsl_kernel + def author(x): + return x + offset + + record = author.export({"x": "uint64"}, "uint64", version="1.0") + offset = np.uint64(99) + kernel = blosc2.PortableKernel.from_json(record) + np.testing.assert_array_equal(kernel.evaluate({"x": np.arange(3, dtype="uint64")}), [7, 8, 9]) + text = "ß" + + @blosc2.dsl_kernel + def string_author(x): + return x + text + + record = string_author.export({"x": "U2"}, "U3", version="1.0") + text = "changed" + np.testing.assert_array_equal( + blosc2.PortableKernel.from_json(record).evaluate({"x": np.array(["a"], dtype="U2")}), ["aß"] + ) + static = blosc2.DSLKernel.from_source("def rows(x):\n return block_sum(x) + _n0\n") + record = static.export({"x": "int64"}, "int64", version="1.0", cardinality="block_scalar", ndim=1) + assert blosc2.PortableKernel.from_json(record).result_cardinality == "block_scalar" + + minimum = np.int64(np.iinfo(np.int64).min) + + @blosc2.dsl_kernel + def minimum_capture(x): + return x + minimum + + record = minimum_capture.export( + {"x": "float64"}, "float64", version="1.0", capture_dtypes={"minimum": "float64"} + ) + minimum = np.int64(0) + np.testing.assert_array_equal( + blosc2.PortableKernel.from_json(record).evaluate({"x": np.array([0.0])}), [-float(2**63)] + ) + loop = blosc2.DSLKernel.from_source("def k(x):\n for i in range(x):\n y = i\n return i\n") + native_loop = blosc2.PortableKernel.from_json(loop.export({"x": "int64"}, "int64", version="1.0")) + np.testing.assert_array_equal(native_loop.evaluate({"x": np.array([2, 4], dtype="int64")}), [1, 3]) + + @blosc2.dsl_kernel + def static_row(row): + return np.sqrt(row["x"]) + row["y"] + + bound = dict(zip(static_row.input_names, ("float64", "float64"), strict=True)) + native = blosc2.PortableKernel.from_json(static_row.export(bound, "float64", version="1.0")) + arrays = dict(zip(static_row.input_names, (np.array([4.0]), np.array([3.0])), strict=True)) + np.testing.assert_array_equal(native.evaluate(arrays), [5.0]) + with pytest.raises(blosc2.PortableArtifactError): + author.export({"x": "uint64"}, "uint64", version="1.0", constants={"unknown": 1}) + + +def test_table_native_row_contract_roundtrip(tmp_path, monkeypatch): + @dataclass + class Row: + x: int = 0 + + source = blosc2.DSLKernel.from_source("def rows(x):\n return block_sum(x) + _flat_idx + _n0\n") + kernel = blosc2.PortableKernel.from_json(source.export({"x": "int64"}, "int64", version="1.0", ndim=1)) + table = blosc2.CTable(Row, new_data={"x": [2, 4]}, create_summary_index=False) + table.add_computed_column("virtual", kernel, inputs={"x": "x"}) + old_draft = {**table._computed_cols["virtual"], "row_domain": "independent"} + assert table._validate_portable_table_metadata(old_draft)["kind"] == "portable" + with pytest.raises(ValueError, match="independent"): + table._validate_portable_table_metadata({**old_draft, "row_domain": "dynamic"}) + table.add_generated_column("stored", values=source, dtype="int64", inputs={"x": "x"}) + np.testing.assert_array_equal(table["virtual"][:], [3, 5]) + table.append({"x": 8}) + np.testing.assert_array_equal(table["stored"][:], [3, 5, 9]) + table.refresh_generated_column("stored") + path = tmp_path / "table.b2d" + table.save(str(path)) + import blosc2.b2objects as b2objects + + monkeypatch.setattr( + b2objects, "kernel_from_source", lambda *a, **k: pytest.fail("Python reconstruction") + ) + # The public package attribute is a decorator; import the actual module. + dsl_module = importlib.import_module("blosc2.dsl_kernel") + monkeypatch.setattr( + dsl_module, "kernel_from_source", lambda *a, **k: pytest.fail("Python reconstruction") + ) + reopened = blosc2.CTable.open(str(path), mode="a") + np.testing.assert_array_equal(reopened["virtual"][:], [3, 5, 9]) + reopened.append({"x": 10}) + np.testing.assert_array_equal(reopened["stored"][:], [3, 5, 9, 11]) + framed = blosc2.ctable_from_cframe(reopened.to_cframe()) + np.testing.assert_array_equal(framed["stored"][:], [3, 5, 9, 11]) + reopened.materialize_computed_column("virtual", new_name="derived") + reopened.delete(1) + copied = reopened.copy(compact=True) + np.testing.assert_array_equal(copied["virtual"][:], [3, 9, 11]) + np.testing.assert_array_equal(copied["derived"][:], [3, 9, 11]) + copied.extend({"x": [12, 14]}) + np.testing.assert_array_equal(copied["stored"][:], [3, 9, 11, 13, 15]) + constructor = blosc2.DSLKernel.from_source("def constant_row():\n return _n0\n") + constructed = blosc2.PortableKernel.from_json(constructor.export({}, "int64", version="1.0", ndim=1)) + copied.add_generated_column("constant", values=constructed, inputs={}) + copied.append({"x": 16}) + copied.refresh_generated_column("constant") + np.testing.assert_array_equal(copied["constant"][:], np.ones(6, dtype="int64")) + sentinel = tmp_path / "preserved.b2z" + sentinel.write_bytes(b"original destination") + copied._computed_cols["virtual"]["artifact"] = "{}" + with pytest.raises(blosc2.PortableArtifactError): + copied.save(str(sentinel)) + assert sentinel.read_bytes() == b"original destination" + with pytest.raises(TypeError, match="row_domain"): + table.add_computed_column("invalid", kernel, inputs={"x": "x"}, row_domain="dynamic") + assert not hasattr(table, "add_portable_computed_column") + assert not hasattr(table, "add_portable_generated_column") + + @dataclass + class TextRow: + label: str = blosc2.field(blosc2.string(max_length=4), default="") + + text_table = blosc2.CTable(TextRow, new_data={"label": ["ß a", "ab"]}, create_summary_index=False) + upper = blosc2.DSLKernel.from_source("def upper_row(x):\n return upper(x)\n") + text_table.add_generated_column("upper", values=upper, dtype="U4", inputs={"x": "label"}) + text_table.append({"label": "z"}) + np.testing.assert_array_equal(text_table["upper"][:], ["SS A", "AB", "Z"]) + + @dataclass + class VectorRow: + vector: object = blosc2.field(blosc2.ndarray((3,), dtype=blosc2.int64())) + bias: int = 0 + + vector_table = blosc2.CTable( + VectorRow, new_data={"vector": [[1, 2, 3], [4, 5, 6]], "bias": [1, 2]}, create_summary_index=False + ) + total = blosc2.DSLKernel.from_source("def total_row(x, bias):\n return block_sum(x + bias) + _n0\n") + vector_table.add_generated_column( + "total", + values=total, + dtype="int64", + cardinality="block_scalar", + inputs={"x": "vector", "bias": "bias"}, + ) + vector_table.append({"vector": [7, 8, 9], "bias": 3}) + vector_table.refresh_generated_column("total") + restored = blosc2.ctable_from_cframe(vector_table.to_cframe()) + np.testing.assert_array_equal(restored["total"][:], [12, 24, 36]) + + +@pytest.mark.parametrize("generated", [False, True]) +def test_unified_table_registration_is_row_local_and_validated(tmp_path, generated): + @dataclass + class Row: + amount: float = 0.0 + + table = blosc2.CTable( + Row, + urlpath=str(tmp_path / "rows.b2d"), + mode="w", + new_data={"amount": [2.0, 4.0, 8.0]}, + create_summary_index=False, + ) + kernel = blosc2.DSLKernel.from_source("def center(x):\n return x - block_mean(x)\n") + if generated: + table.add_generated_column("centered", values=kernel, inputs={"x": "amount"}, create_index=True) + else: + table.add_computed_column("centered", kernel, inputs={"x": "amount"}) + np.testing.assert_array_equal(table["centered"][:], [0, 0, 0]) + table.append({"amount": 16.0}) + np.testing.assert_array_equal(table["centered"][1:3], [0, 0]) + schema = table._schema_dict_with_computed() + recipe = schema["materialized_columns" if generated else "computed_columns"][0] + assert "row_domain" not in recipe + assert "dsl_source" not in recipe + invalid = blosc2.DSLKernel.from_source("def invalid(x):\n return callback(x)\n") + if generated: + with pytest.raises(blosc2.PortableArtifactError): + table.add_generated_column("invalid", values=invalid, inputs={"x": "amount"}) + else: + with pytest.raises(blosc2.PortableArtifactError): + table.add_computed_column("invalid", invalid, inputs={"x": "amount"}) + assert "invalid" not in table.col_names + table.close() + restored = blosc2.CTable.open(str(tmp_path / "rows.b2d")) + np.testing.assert_array_equal(restored["centered"][:], [0, 0, 0, 0]) + restored.close() diff --git a/tests/test_prepared_evaluate.py b/tests/test_prepared_evaluate.py new file mode 100644 index 000000000..8fa38f839 --- /dev/null +++ b/tests/test_prepared_evaluate.py @@ -0,0 +1,178 @@ +"""Explicit reusable evaluator contracts, independent of NumExpr availability.""" + +import gc +import weakref +from concurrent.futures import ThreadPoolExecutor + +import numpy as np +import pytest + +import blosc2 + + +def test_rebind_shape_dtype_output_and_release(): + evaluator = blosc2.prepare_evaluate("x + y", order="F") + assert evaluator.input_names == ("x", "y") + for shape, dtype in [((3, 4), "float64"), ((17,), "int64")]: + x = np.ones(shape, dtype=dtype) + out = np.empty_like(x) + refs = [weakref.ref(x), weakref.ref(out)] + assert evaluator({"x": x, "y": x}, out=out) is out + np.testing.assert_array_equal(out, 2) + del x, out + gc.collect() + assert all(ref() is None for ref in refs) + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Host thread pools are unavailable on WASM") +def test_concurrent_rebinding(): + evaluator = blosc2.prepare_evaluate("x * 2") + + def run(value): + x = np.full(257, value, dtype="float64") + result = evaluator.evaluate({"x": x}) + np.testing.assert_array_equal(result, x * 2) + + with ThreadPoolExecutor(max_workers=4) as pool: + list(pool.map(run, range(12))) + + +def test_missing_operand_does_not_capture_caller(): + evaluator = blosc2.prepare_evaluate("x + y") + with pytest.raises(NameError, match="y"): + evaluator({"x": np.ones(3)}) + + +def test_options_are_validated_and_overrides_do_not_mutate(): + with pytest.raises(ValueError, match="optimization"): + blosc2.prepare_evaluate("x", optimization="invalid") + evaluator = blosc2.prepare_evaluate("x + 1", order="F") + x = np.arange(12.0).reshape(3, 4) + assert evaluator({"x": x}, order="C").flags.c_contiguous + assert evaluator({"x": x}).flags.f_contiguous + + +@pytest.mark.parametrize("expression", ["x", "copy(x)", "x + 1", "where(x > 0, x, -x)"]) +@pytest.mark.parametrize("direction", [1, -1]) +def test_overlapping_destination(expression, direction): + data = np.arange(34.0) + x, out = (data[:-1], data[1:]) if direction == 1 else (data[1:], data[:-1]) + original = x.copy() + expected = original + 1 if expression == "x + 1" else original + assert blosc2.evaluate(expression, local_dict={"x": x}, out=out) is out + np.testing.assert_array_equal(out, expected) + + +@pytest.mark.parametrize("order", ["C", "F"]) +@pytest.mark.parametrize( + "options", + [ + {"optimization": "invalid"}, + {"truediv": "invalid"}, + {"sanitize": 1}, + {"disable_cache": 1}, + {"unknown": True}, + ], +) +def test_invalid_options_rejected_before_output_writes(order, options): + x = np.arange(12.0).reshape(3, 4) + out = np.full(x.shape, -999.0, order=order) + with pytest.raises((ValueError, TypeError)): + blosc2.evaluate("x + 1", local_dict={"x": x}, out=out, **options) + np.testing.assert_array_equal(out, -999) + + +@pytest.mark.parametrize(("reducer", "expected"), [("sum", 0), ("prod", 1)]) +def test_empty_reduction_identity(reducer, expected): + out = np.empty(()) + result = blosc2.evaluate(f"{reducer}(x)", local_dict={"x": np.empty(0)}, out=out) + assert result is out + assert result == expected + + +def test_wrong_output_shape_rejected(): + with pytest.raises(ValueError): + blosc2.evaluate("x + 1", local_dict={"x": np.ones((2, 3))}, out=np.empty((3, 2))) + + +@pytest.mark.parametrize("mode", ["safe", "full"]) +@pytest.mark.parametrize("layout", ["C", "F"]) +@pytest.mark.parametrize( + "options", + [ + {"optimization": "none"}, + {"optimization": "moderate"}, + {"optimization": "aggressive"}, + ], +) +def test_keyword_behavior_across_layouts(mode, layout, options): + x = np.arange(12.0).reshape(3, 4) + out = np.empty(x.shape, order=layout) + with blosc2.expression_evaluation(mode): + result = blosc2.evaluate("x / 2 + 1", local_dict={"x": x}, out=out, **options) + assert result is out + np.testing.assert_array_equal(result, x / 2 + 1) + + +def test_safe_mode_rejects_unsafe_expression(): + with blosc2.expression_evaluation("safe"), pytest.raises(blosc2.exceptions.UnsafeDeserializationError): + blosc2.evaluate("__import__('os')", local_dict={}) + + +@pytest.mark.parametrize("out_provided", [False, True]) +def test_empty_axis_reduction(out_provided): + x = np.empty((2, 0, 3)) + out = np.empty((2, 3)) if out_provided else None + result = blosc2.evaluate("sum(x, axis=1)", local_dict={"x": x}, out=out) + if out_provided: + assert result is out + np.testing.assert_array_equal(result, x.sum(axis=1)) + + +@pytest.mark.parametrize("reducer", ["min", "max"]) +def test_empty_extrema_raise(reducer): + with pytest.raises(ValueError): + blosc2.evaluate(f"{reducer}(x)", local_dict={"x": np.empty(0)}) + + +def test_prepared_broadcast_scalar_and_compressed_rebinding(): + evaluator = blosc2.prepare_evaluate("x + y") + x = np.arange(12.0).reshape(3, 4) + y = np.arange(4.0) + np.testing.assert_array_equal(evaluator({"x": x, "y": y}), x + y) + stored = blosc2.asarray(x) + np.testing.assert_array_equal(evaluator({"x": stored, "y": 2}), x + 2) + assert blosc2.prepare_evaluate("3.0")({}) == 3.0 + + +def test_numpy_fallback_options_without_numexpr(monkeypatch): + import importlib + + module = importlib.import_module("blosc2.lazyexpr") + monkeypatch.setattr(module, "numexpr", None) + x = np.arange(12.0).reshape(3, 4) + evaluator = blosc2.prepare_evaluate("x / 2", order="F") + result = evaluator({"x": x}) + assert result.flags.f_contiguous + np.testing.assert_array_equal(result, x / 2) + with pytest.raises(ValueError, match="optimization"): + evaluator({"x": x}, optimization="invalid") + + +def test_prepared_safe_policy_is_preserved(monkeypatch): + import importlib + + module = importlib.import_module("blosc2.lazyexpr") + original = module.evaluate + seen = [] + + def record(*args, **kwargs): + seen.append(module.evaluation_mode()) + return original(*args, **kwargs) + + monkeypatch.setattr(module, "evaluate", record) + with blosc2.expression_evaluation("safe"): + evaluator = blosc2.prepare_evaluate("x + 1") + with blosc2.expression_evaluation("full"): + evaluator({"x": np.arange(3.0)}) + assert seen == ["safe"] diff --git a/tests/test_pytest_configuration.py b/tests/test_pytest_configuration.py new file mode 100644 index 000000000..57957040a --- /dev/null +++ b/tests/test_pytest_configuration.py @@ -0,0 +1,26 @@ +"""Wheel smoke tests can disable pytest's optional cache provider.""" + +import os +import shutil +import subprocess +import sys +from pathlib import Path + +import pytest + +import blosc2 + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Nested pytest requires subprocess support") +def test_without_cache_provider(tmp_path): + shutil.copyfile(Path(__file__).with_name("conftest.py"), tmp_path / "conftest.py") + (tmp_path / "test_smoke.py").write_text("def test_smoke():\n pass\n", encoding="utf-8") + result = subprocess.run( + [sys.executable, "-m", "pytest", "-p", "no:cacheprovider", "-q", "test_smoke.py"], + cwd=tmp_path, + env={**os.environ, "PYTEST_ADDOPTS": ""}, + capture_output=True, + text=True, + timeout=30, + ) + assert result.returncode == 0, result.stdout + result.stderr diff --git a/tests/test_re_evaluate.py b/tests/test_re_evaluate.py new file mode 100644 index 000000000..1d8ebc4ae --- /dev/null +++ b/tests/test_re_evaluate.py @@ -0,0 +1,146 @@ +"""Thread-local convenience state is independent of explicit prepared recipes.""" + +import gc +import importlib +import threading +import weakref +from concurrent.futures import ThreadPoolExecutor + +import numpy as np +import pytest + +import blosc2 + +module = importlib.import_module("blosc2.prepared_evaluate") + + +@pytest.fixture(autouse=True) +def clean_last_expression(): + previous = getattr(module._evaluation_state, "last", None) + module._evaluation_state.last = None + yield + module._evaluation_state.last = previous + + +def test_requires_previous_success(): + with pytest.raises(RuntimeError, match="evaluate"): + blosc2.re_evaluate() + + +def test_caller_scope_and_explicit_output_rebinding(): + x = np.arange(12.0) + out = np.empty_like(x) + assert blosc2.evaluate("x + 1", out=out) is out + x = x + 10 + assert blosc2.re_evaluate() is out + np.testing.assert_array_equal(out, x + 1) + x = x + 20 + assert blosc2.re_evaluate(local_dict={"x": x}, global_dict={}) is out + np.testing.assert_array_equal(out, x + 1) + + +def test_global_lookup_and_frame_depth(): + blosc2.evaluate("x + y", local_dict={"x": np.ones(3)}, global_dict={"y": 2}) + result = blosc2.re_evaluate(local_dict={"x": np.ones(3)}, global_dict={"y": 4}) + np.testing.assert_array_equal(result, 5) + x, y = np.arange(3.0), 8 + + def wrapper(): + return blosc2.re_evaluate(_frame_depth=3) + + np.testing.assert_array_equal(wrapper(), x + y) + + +def test_arrays_not_retained_and_dead_output_allocates_fresh(): + x = np.arange(7.0) + out = np.empty_like(x) + references = [weakref.ref(x), weakref.ref(out)] + blosc2.evaluate("x + 1", local_dict={"x": x}, out=out) + del x, out + gc.collect() + assert all(reference() is None for reference in references) + result = blosc2.re_evaluate(local_dict={"x": np.arange(7.0)}, global_dict={}) + np.testing.assert_array_equal(result, np.arange(7.0) + 1) + + +def test_fresh_output_and_option_reuse(): + x = np.arange(12.0).reshape(3, 4) + first = blosc2.evaluate("x + 1", local_dict={"x": x}, order="F") + second = blosc2.re_evaluate(local_dict={"x": x + 1}, global_dict={}) + assert second is not first + assert second.flags.f_contiguous + np.testing.assert_array_equal(second, x + 2) + + +def test_failed_call_and_prepared_evaluation_preserve_state(): + x = np.arange(5.0) + blosc2.evaluate("x + 1", local_dict={"x": x}) + with pytest.raises(ValueError): + blosc2.evaluate("x + 2", local_dict={"x": x}, order="invalid") + blosc2.prepare_evaluate("x * 100")({"x": x}) + np.testing.assert_array_equal(blosc2.re_evaluate({"x": x}), x + 1) + + +def test_rebinding_is_checked_and_failure_does_not_destroy_state(): + x = np.arange(5.0) + out = np.empty_like(x) + blosc2.evaluate("x + 1", local_dict={"x": x}, out=out) + with pytest.raises(ValueError): + blosc2.re_evaluate({"x": np.ones(9)}) + assert blosc2.re_evaluate({"x": x}) is out + np.testing.assert_array_equal(out, x + 1) + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Host thread pools are unavailable on WASM") +def test_thread_isolation(): + barrier = threading.Barrier(2) + + def run(offset): + with pytest.raises(RuntimeError): + blosc2.re_evaluate() + x = np.arange(5.0) + blosc2.evaluate(f"x + {offset}", local_dict={"x": x}) + barrier.wait(timeout=10) + result = blosc2.re_evaluate({"x": x + 10}) + np.testing.assert_array_equal(result, x + 10 + offset) + + with ThreadPoolExecutor(max_workers=2) as pool: + list(pool.map(run, [1, 100])) + with pytest.raises(RuntimeError): + blosc2.re_evaluate() + + +def test_nested_evaluation_does_not_replace_state_on_failure(monkeypatch): + lazy = importlib.import_module("blosc2.lazyexpr") + x = np.arange(5.0) + blosc2.evaluate("x + 1", local_dict={"x": x}) + original = lazy._prepare_cached_evaluate + + def prepare(expression, *args): + if expression == "x + 2": + blosc2.evaluate("x * 100", local_dict={"x": x}) + raise ValueError("outer failure") + return original(expression, *args) + + monkeypatch.setattr(lazy, "_prepare_cached_evaluate", prepare) + with pytest.raises(ValueError, match="outer failure"): + blosc2.evaluate("x + 2", local_dict={"x": x}) + np.testing.assert_array_equal(blosc2.re_evaluate({"x": x}), x + 1) + + +def test_saved_safe_mode_is_preserved(monkeypatch): + lazy = importlib.import_module("blosc2.lazyexpr") + x = np.arange(5.0) + with blosc2.expression_evaluation("safe"): + blosc2.evaluate("x + 1", local_dict={"x": x}) + original = lazy.evaluate + modes = [] + + def record(*args, **kwargs): + modes.append(lazy.evaluation_mode()) + return original(*args, **kwargs) + + monkeypatch.setattr(lazy, "evaluate", record) + with blosc2.expression_evaluation("full"): + blosc2.re_evaluate({"x": x}) + assert modes == ["safe"] diff --git a/tests/test_releasegil_isolation.py b/tests/test_releasegil_isolation.py new file mode 100644 index 000000000..ed7122080 --- /dev/null +++ b/tests/test_releasegil_isolation.py @@ -0,0 +1,12 @@ +"""Changing the compression GIL policy must not affect the following test.""" + +import pytest + +import blosc2 + + +@pytest.mark.parametrize("gil", [True, False]) +def test_releasegil_starts_disabled(gil): + # Deliberately leave the setting changed. The autouse fixture must restore + # it before the next parameter (or a Python filler/prefilter) executes. + assert blosc2.set_releasegil(gil) is False diff --git a/tests/test_remote_caterva2.py b/tests/test_remote_caterva2.py index 160d3a627..b1f29d63d 100644 --- a/tests/test_remote_caterva2.py +++ b/tests/test_remote_caterva2.py @@ -26,15 +26,6 @@ class ReadingBig: value: int = blosc2.field(blosc2.int32(), chunks=(256,), blocks=(64,)) -@dataclasses.dataclass -class ReadingRich: - ident: int = blosc2.field(blosc2.int64()) - text: str = blosc2.field(blosc2.utf8(null_storage="mask")) - category: str = blosc2.field(blosc2.dictionary(nullable=True)) - tags: list[int] = blosc2.field(blosc2.list(blosc2.int32(), nullable=True, batch_rows=128)) # noqa: RUF009 - when: object = blosc2.field(blosc2.timestamp(unit="ns", null_storage="mask")) - - def safe(value): if dataclasses.is_dataclass(value) and not isinstance(value, type): return safe(dataclasses.asdict(value)) @@ -56,6 +47,17 @@ def caterva2_source(request): array = blosc2.asarray(np.arange(60, dtype=np.int32).reshape(6, 10), chunks=(3, 5), blocks=(1, 5)) nrows = getattr(request, "param", 12) if nrows in ("rich", "rich-large"): + if not hasattr(np.dtypes, "StringDType"): + pytest.skip("Rich Caterva2 schemas require NumPy >= 2.0 (StringDType)") + + @dataclasses.dataclass + class ReadingRich: + ident: int = blosc2.field(blosc2.int64()) + text: str = blosc2.field(blosc2.utf8(null_storage="mask")) + category: str = blosc2.field(blosc2.dictionary(nullable=True)) + tags: list[int] = blosc2.field(blosc2.list(blosc2.int32(), nullable=True, batch_rows=128)) # noqa: RUF009 + when: object = blosc2.field(blosc2.timestamp(unit="ns", null_storage="mask")) + rich_rows = 31 if nrows == "rich" else 1031 category_boundary = 16 if nrows == "rich" else 1024 table = blosc2.CTable( diff --git a/tests/test_remote_store_cache_locking.py b/tests/test_remote_store_cache_locking.py new file mode 100644 index 000000000..800323acc --- /dev/null +++ b/tests/test_remote_store_cache_locking.py @@ -0,0 +1,53 @@ +"""Windows operation-scoped cache locks wait beyond msvcrt's fixed retry budget.""" + +import errno +import sys +from types import SimpleNamespace + +import pytest + +import blosc2.remote_store_cache as cache + + +@pytest.mark.parametrize("blocking", [False, True]) +def test_windows_cache_lock_contention(tmp_path, monkeypatch, blocking): + calls, waits = [], [] + with (tmp_path / "owner.lock").open("a+b") as stream: + + def locking(fd, mode, count): + assert fd == stream.fileno() + assert mode == 2 + assert count == 1 + assert stream.tell() == 0 + calls.append(True) + if len(calls) <= 12: + raise PermissionError(errno.EACCES, "another process owns the lock") + + monkeypatch.setattr(cache, "os", SimpleNamespace(name="nt")) + monkeypatch.setitem(sys.modules, "msvcrt", SimpleNamespace(LK_NBLCK=2, locking=locking)) + monkeypatch.setattr(cache, "time", SimpleNamespace(sleep=waits.append)) + if blocking: + cache.lock_cache_file(stream, blocking=True) + assert len(calls) == 13 + assert waits == [0.05] * 12 + else: + with pytest.raises(PermissionError): + cache.lock_cache_file(stream) + assert len(calls) == 1 + assert not waits + assert stream.seek(0, 2) == 0 # Never write a byte that another owner may have locked. + + +def test_windows_cache_lock_non_contention_error_is_not_retried(tmp_path, monkeypatch): + def locking(*args): + raise OSError(errno.EBADF, "invalid descriptor") + + def forbidden(*args): + pytest.fail("Unrelated IO errors must not retry") + + monkeypatch.setattr(cache, "os", SimpleNamespace(name="nt")) + monkeypatch.setitem(sys.modules, "msvcrt", SimpleNamespace(LK_NBLCK=2, locking=locking)) + monkeypatch.setattr(cache, "time", SimpleNamespace(sleep=forbidden)) + with (tmp_path / "owner.lock").open("a+b") as stream: + with pytest.raises(OSError, match="invalid descriptor"): + cache.lock_cache_file(stream, blocking=True) diff --git a/tests/test_resident_execution.py b/tests/test_resident_execution.py new file mode 100644 index 000000000..37867b729 --- /dev/null +++ b/tests/test_resident_execution.py @@ -0,0 +1,335 @@ +import numpy as np +import pytest + +import blosc2 +from blosc2.resident_execution import ( + evaluate_resident, + resident_integer_operations_safe, + resident_scalar_operations_safe, +) + + +@pytest.fixture(autouse=True) +def runtime(): + if not getattr(blosc2.blosc2_ext, "portable_resident_available", lambda: False)(): + pytest.skip("Requires rebuilt parallel resident binding") + previous = blosc2.nthreads + blosc2.set_nthreads(4) + yield + blosc2.set_nthreads(previous) + + +def kernel(source="def k(x, y):\n return x + (y - 1)\n", dtype="float64", output=None, jit=True): + author = blosc2.DSLKernel.from_source(source) + return blosc2.PortableKernel.from_json(author.export({"x": dtype, "y": dtype}, output or dtype), jit=jit) + + +@pytest.mark.parametrize("dtype", ["float32", "float64"]) +@pytest.mark.parametrize("jit", [False, True]) +@pytest.mark.skipif(blosc2.IS_WASM, reason="Parallel resident execution requires host threads") +def test_full_read_parallel(dtype, jit): + values = np.arange(600_003, dtype=dtype).reshape(3, 200001) + lazy = kernel(dtype=dtype, jit=jit).lazy({"x": values, "y": values}) + np.testing.assert_array_equal(lazy[:], values + (values - 1)) + report = lazy._source_execution_report + assert report["route"] == "parallel-resident" + assert report["threads"] == 4 + assert report["input_buffer_bytes"] == 0 + + +@pytest.mark.parametrize("dtype", ["int8", "int64", "uint64"]) +@pytest.mark.parametrize("jit", [False, True]) +@pytest.mark.skipif(blosc2.IS_WASM, reason="Parallel resident execution requires host threads") +def test_integer_modular_full_read(dtype, jit, monkeypatch): + monkeypatch.setattr("blosc2.resident_execution.MINIMUM_WORKER_ITEMS", 256) + bounds = np.iinfo(dtype) + # Include wrap boundaries and a worker tail, without overflowing Python scalars. + values = np.resize(np.array([bounds.min, bounds.max, 0, 1], dtype=dtype), 1027) + # Exhaustive dtype/operator arithmetic parity belongs in miniexpr. Here, + # exercise binding and actual parallel dispatch for a nested integer recipe. + native = kernel(dtype=dtype, jit=jit) + lazy = native.lazy({"x": values, "y": values}) + expected = values + (values - 1) + np.testing.assert_array_equal(lazy[:], expected) + assert lazy._source_execution_report["route"] == "parallel-resident" + assert lazy._source_execution_report["threads"] == 4 + + +@pytest.mark.parametrize( + ("expression", "dtype", "safe"), + [ + ("x + 1", "int8", True), + ("x + (-128)", "int8", True), + ("x + 128", "int8", False), + ("x + (-129)", "int8", False), + ("x + (-1)", "uint64", False), + ("x + 18446744073709551615", "uint64", True), + ("x + (1 + 2)", "int64", False), + ("x + (9223372036854775807 + 1)", "int64", False), + ("x + SCALE", "int64", False), + ("x // y", "int64", False), + ("x << 1", "int64", False), + ("int64(x) + 1", "int64", False), + ("where(x > 0, x, y)", "int64", False), + ("x + 1.0", "int64", False), + ("1 + 2", "int64", False), + ("x + True", "int64", False), + ], +) +def test_integer_safety_proof(expression, dtype, safe): + from types import SimpleNamespace + + dtype = np.dtype(dtype) + fake = SimpleNamespace( + source=f"def k(x, y):\n return {expression}\n", + input_dtypes={"x": dtype, "y": dtype}, + output_dtype=dtype, + inferred_dtype=dtype, + result_cardinality="elementwise", + context_ndim=0, + ) + assert resident_integer_operations_safe(fake) == safe + + +@pytest.mark.parametrize("case", ["mixed", "conversion", "context", "reduction"]) +def test_integer_contract_rejected(case): + from types import SimpleNamespace + + dtype = np.dtype("int64") + fake = SimpleNamespace( + source="def k(x, y):\n return x + y\n", + input_dtypes={"x": dtype, "y": np.dtype("int8") if case == "mixed" else dtype}, + output_dtype=dtype, + inferred_dtype=np.dtype("int8") if case == "conversion" else dtype, + result_cardinality="block_scalar" if case == "reduction" else "elementwise", + context_ndim=1 if case == "context" else 0, + ) + assert not resident_integer_operations_safe(fake) + + +@pytest.mark.parametrize( + "case", ["small", "strided", "broadcast", "partial", "single-thread", "conversion", "weak", "mixed"] +) +def test_integer_conservative_fallback(case, monkeypatch): + monkeypatch.setattr("blosc2.resident_execution.MINIMUM_WORKER_ITEMS", 128) + values = np.arange(1027, dtype="int64") + other = values + expression = "x + y" + output = "float64" if case == "conversion" else "int64" + if case == "small": + values = other = values[:10] + elif case == "strided": + values = other = values[::-1] + elif case == "broadcast": + other = values[:1] + elif case == "single-thread": + blosc2.set_nthreads(1) + elif case == "mixed": + other = other.astype("int32") + elif case == "weak": + expression = "x + (1 + 2)" + author = blosc2.DSLKernel.from_source(f"def k(x, y):\n return {expression}\n") + native = blosc2.PortableKernel.from_json(author.export({"x": values.dtype, "y": other.dtype}, output)) + lazy = native.lazy({"x": values, "y": other}) + + def forbidden(*args, **kwargs): + pytest.fail("Ineligible integer recipe scheduled resident workers") + + monkeypatch.setattr("blosc2.resident_execution.resident_pool", forbidden) + selection = slice(0, 100) if case == "partial" else slice(None) + expected = values + 3 if case == "weak" else values + other + np.testing.assert_array_equal(lazy[selection], expected.astype(output)[selection]) + + +@pytest.mark.parametrize("case", ["small", "strided", "broadcast", "partial", "single-thread"]) +def test_conservative_fallback(case, monkeypatch): + values = np.arange(600_003.0) + other = values + if case == "small": + values = other = values[:1000] + elif case == "strided": + values = other = values[::-1] + elif case == "broadcast": + other = values[:1] + elif case == "single-thread": + blosc2.set_nthreads(1) + lazy = kernel().lazy({"x": values, "y": other}) + + def forbidden(*args, **kwargs): + pytest.fail("Ineligible resident execution scheduled") + + monkeypatch.setattr("blosc2.resident_execution.resident_pool", forbidden) + selection = slice(0, 100) if case == "partial" else slice(None) + np.testing.assert_array_equal(lazy[selection], (values + (other - 1))[selection]) + + +def test_threadless_runtime_keeps_serial_values(monkeypatch): + values = np.arange(600_003.0) + lazy = kernel().lazy({"x": values, "y": values}) + monkeypatch.setattr(blosc2, "IS_WASM", True) + + def forbidden(*args, **kwargs): + pytest.fail("Threadless runtime scheduled resident workers") + + monkeypatch.setattr("blosc2.resident_execution.resident_pool", forbidden) + np.testing.assert_array_equal(lazy[:], values + (values - 1)) + + +def test_reduction_retains_logical_partition(monkeypatch): + # Keep four workers eligible without a large interpreted block reduction. + # If the reduction gate regresses, this still schedules forbidden workers. + monkeypatch.setattr("blosc2.resident_execution.MINIMUM_WORKER_ITEMS", 256) + values = np.arange(1027.0) + native = kernel("def k(x, y):\n return x + block_sum(y)\n") + lazy = native.lazy({"x": values, "y": values}) + + def forbidden(*args, **kwargs): + pytest.fail("Reduction was repartitioned") + + monkeypatch.setattr("blosc2.resident_execution.resident_pool", forbidden) + np.testing.assert_array_equal(lazy[:], values + values.sum()) + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Parallel FP aggregation requires host threads") +def test_fp_status_aggregation(): + values = np.linspace(-1, 1, 600_003) + native = kernel("def k(x, y):\n return sqrt(x) + y\n") + expected, status = native.evaluate_block({"x": values, "y": values}, return_status=True) + lazy = native.lazy({"x": values, "y": values}) + np.testing.assert_array_equal(lazy[:], expected) + assert lazy._source_execution_report["fp_flags"] == status["flags"] + assert lazy._source_execution_report["fp_supported"] == status["supported"] + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Parallel resident execution requires host threads") +def test_boolean_output(): + values = np.linspace(-1, 1, 600_003) + native = kernel("def k(x, y):\n return x > y\n", output="bool") + lazy = native.lazy({"x": values, "y": np.zeros_like(values)}) + np.testing.assert_array_equal(lazy[:], values > 0) + assert lazy._source_execution_report["route"] == "parallel-resident" + + +@pytest.mark.parametrize("dtype", ["int64", "float64"]) +def test_selected_resident_views(dtype, monkeypatch): + monkeypatch.setattr("blosc2.resident_execution.MINIMUM_WORKER_ITEMS", 16) + values = np.arange(513, dtype=dtype).reshape(3, 171)[:, ::-1] + other = np.array([2], dtype=dtype) + native = kernel(dtype=dtype) + lazy = native.lazy({"x": values, "y": other}, partitions=(1, 57)) + expected = values + (other - 1) + for selection in ( + (slice(None), slice(2, 160, 2)), + (1, slice(None, None, -2)), + (slice(None), slice(0, 0)), + (-1, -1), + ): + np.testing.assert_array_equal(lazy[selection], expected[selection]) + assert lazy._source_execution_report["route"] in ( + "resident-selection", + "parallel-resident-selection", + ) + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Parallel resident execution requires host threads") +def test_integer_comparison_parallel_and_selected(monkeypatch): + monkeypatch.setattr("blosc2.resident_execution.MINIMUM_WORKER_ITEMS", 64) + values = np.arange(1027, dtype="int64") + lazy = kernel("def k(x, y):\n return x < y\n", dtype="int64", output="bool").lazy( + {"x": values, "y": values[::-1].copy()} + ) + np.testing.assert_array_equal(lazy[:], values < values[::-1]) + assert lazy._source_execution_report["route"] == "parallel-resident" + np.testing.assert_array_equal(lazy[::2], (values < values[::-1])[::2]) + assert lazy._source_execution_report["route"] == "parallel-resident-selection" + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Worker joining requires host threads") +def test_failures_join_and_never_replay(): + import threading + from types import SimpleNamespace + + values = np.arange(600_003.0) + calls = [] + lock = threading.Lock() + + def fail(inputs, shape, **kwargs): + origin = int(inputs["x"][0]) + with lock: + calls.append(origin) + raise OSError(f"Failed region {origin}") + + fake = SimpleNamespace(output_dtype=values.dtype, _handle=SimpleNamespace(evaluate_block=fail)) + with pytest.raises(OSError, match=r"Failed region 0$"): + evaluate_resident(fake, {"x": values}, values.shape, 4) + assert len(calls) == 4 + + +def test_private_output_rejects_alias_and_wrong_dtype(): + native = kernel() + values = np.arange(10.0) + with pytest.raises(ValueError, match="alias"): + native._handle.evaluate_block({"x": values, "y": values}, values.shape, _output=values) + with pytest.raises(ValueError, match="signature"): + native._handle.evaluate_block( + {"x": values, "y": values}, values.shape, _output=np.empty(10, dtype="float32") + ) + + +@pytest.mark.parametrize("expression", ["x + (1e30 * 1e30)", "where(x > 0, exp(100), x)"]) +def test_weak_scalar_intermediates_rejected(expression): + from types import SimpleNamespace + + fake = SimpleNamespace( + source=f"def k(x):\n return {expression}\n", input_dtypes={"x": np.dtype("float32")} + ) + assert not resident_scalar_operations_safe(fake) + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Concurrent artifact reads require host threads") +def test_concurrent_reads_share_prepared_artifact(): + from concurrent.futures import ThreadPoolExecutor + + values = np.arange(600_003.0) + native = kernel() + + def evaluate(_): + return native.lazy({"x": values, "y": values})[:] + + with ThreadPoolExecutor(max_workers=2) as pool: + for result in pool.map(evaluate, range(4)): + np.testing.assert_array_equal(result, values * 2 - 1) + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Worker joining requires host threads") +def test_submission_failure_joins_started_workers(monkeypatch): + from concurrent.futures import ThreadPoolExecutor + from threading import Event + from types import SimpleNamespace + + release, finished = Event(), Event() + values = np.arange(600_003.0) + + def evaluate(inputs, shape, **kwargs): + assert release.wait(timeout=10) + kwargs["_output"][:] = inputs["x"] + finished.set() + return kwargs["_output"], {"flags": 0, "supported": True} + + with ThreadPoolExecutor(max_workers=1) as pool: + calls = [] + + def submit(*args, **kwargs): + calls.append(True) + if len(calls) == 2: + release.set() + raise RuntimeError("Submission failed") + return pool.submit(*args, **kwargs) + + monkeypatch.setattr( + "blosc2.resident_execution.resident_pool", lambda: SimpleNamespace(submit=submit) + ) + fake = SimpleNamespace(output_dtype=values.dtype, _handle=SimpleNamespace(evaluate_block=evaluate)) + with pytest.raises(RuntimeError, match="Submission failed"): + evaluate_resident(fake, {"x": values}, values.shape, 4) + assert finished.is_set() diff --git a/tests/test_resident_expression.py b/tests/test_resident_expression.py new file mode 100644 index 000000000..4bd55c65e --- /dev/null +++ b/tests/test_resident_expression.py @@ -0,0 +1,188 @@ +"""The direct resident route retains rebinding, output and execution-error contracts.""" + +import importlib + +import numpy as np +import pytest + +import blosc2 + +lazy = importlib.import_module("blosc2.lazyexpr") +native = importlib.import_module("blosc2.native_graph") + + +@pytest.fixture(autouse=True) +def runtime(native_graph_runtime): + lazy._evaluate_recipe_cache.clear() + yield + lazy._evaluate_recipe_cache.clear() + + +@pytest.mark.parametrize("size", [100_000, 1_000_000]) +def test_resident_read_reuses_schedule_and_rebinds_arrays(monkeypatch, size): + if blosc2.IS_WASM and size >= native._MINIMUM_PARALLEL_ITEMS: + pytest.skip("Large resident fast path requires host threads") + x = np.arange(size, dtype="int64") + y = x + 1 + expr = blosc2.lazyexpr("x + (y - 1)", {"x": x, "y": y}) + schedule = expr._resident_native[2] + + def forbidden(*args, **kwargs): + pytest.fail("Resident read entered general preparation or storage dispatch") + + monkeypatch.setattr(native, "prepare_native_first", forbidden) + monkeypatch.setattr(native, "compute_native_prefilter_if_eligible", forbidden) + first = expr[:] + expr.operands["o0"] = x + 10 + second = expr[:] + assert expr._resident_native[2] is schedule + assert not np.shares_memory(first, second) + np.testing.assert_array_equal(first, x + (y - 1)) + np.testing.assert_array_equal(second, x + 10 + (y - 1)) + report = expr._native_execution_report + assert report["route"] == ("parallel-resident" if report["tasks"] > 1 else "native-resident") + + +@pytest.mark.parametrize("mode", ["full", "safe"]) +@pytest.mark.skipif(blosc2.IS_WASM, reason="Parallel resident preparation requires host threads") +def test_parallel_evaluate_reuses_schedule_without_lazy_dispatch(monkeypatch, mode): + x = np.arange(1_000_000, dtype="int64") + y = x + 1 + schedules = [] + original = native.prepare_resident + + def prepare(*args, **kwargs): + result = original(*args, **kwargs) + assert result is not None + schedules.append(result[2]) + return result + + def forbidden(*args, **kwargs): + pytest.fail("Parallel resident evaluate entered lazy preparation") + + monkeypatch.setattr(native, "prepare_resident", prepare) + monkeypatch.setattr(lazy, "lazyexpr", forbidden) + with blosc2.expression_evaluation(mode): + first = blosc2.evaluate("x + (y - 1)", local_dict={"x": x, "y": y}) + second = blosc2.evaluate("x + (y - 1)", local_dict={"x": x + 10, "y": y}) + assert schedules[0] is schedules[1] + assert not np.shares_memory(first, second) + np.testing.assert_array_equal(first, x + (y - 1)) + np.testing.assert_array_equal(second, x + 10 + (y - 1)) + + +@pytest.mark.skipif(blosc2.IS_WASM, reason="Parallel resident execution requires host threads") +def test_parallel_resident_uses_current_thread_count(monkeypatch): + x = np.arange(1_000_000, dtype="int64") + expr = blosc2.lazyexpr("x + 1", {"x": x}) + schedule = expr._resident_native[2] + for threads in (2, 4, 1): + monkeypatch.setattr(blosc2, "nthreads", threads) + np.testing.assert_array_equal(expr[:], x + 1) + assert expr._resident_native[2] is schedule + assert expr._native_execution_report["tasks"] == threads + + +def test_large_checked_map_retains_general_dispatch(): + x = np.arange(300_000, dtype="int64") + y = x.astype("uint64") + assert native.prepare_resident("x + y", {"x": x, "y": y}) is None + actual = blosc2.evaluate("x + y", local_dict={"x": x, "y": y}) + assert actual.dtype == (x + y).dtype + np.testing.assert_array_equal(actual, x + y) + + +def test_large_weak_scalar_overflow_does_not_write(): + if np.lib.NumpyVersion(np.__version__) < "2.0.0": + pytest.skip("NumPy 2 weak-scalar overflow diagnostics") + x = np.zeros(300_000, dtype="int8") + out = np.full_like(x, -1) + with pytest.raises(OverflowError): + blosc2.evaluate("x + 128", local_dict={"x": x}, out=out) + np.testing.assert_array_equal(out, -1) + + +def test_resident_expression_mutation_invalidates_plan(): + x = np.arange(17.0) + expr = blosc2.lazyexpr("x + 1", {"x": x}) + expr.expression = "o0 + 2" + np.testing.assert_array_equal(expr[:], x + 2) + expr.operands["o0"] = x.astype("float32") + actual = expr[:] + assert actual.dtype == np.dtype("float32") + np.testing.assert_array_equal(actual, x + 2) + + +def test_resident_schedule_tracks_compilation_options(): + x = np.arange(17.0) + with blosc2.jit_options(jit=False, cflags="-O1"): + first = lazy._prepare_cached_evaluate("x + 1", {"x": x}, None) + with blosc2.jit_options(jit=False, cflags="-O2"): + second = lazy._prepare_cached_evaluate("x + 1", {"x": x}, None) + np.testing.assert_array_equal(blosc2.evaluate("x + 1", local_dict={"x": x}), x + 1) + assert first[0] is not second[0] + assert first[0][1] is not second[0][1] + + +@pytest.mark.parametrize("engine", ["evaluate", "lazyexpr"]) +@pytest.mark.parametrize("size", [17, 1_000_000]) +def test_resident_execution_failure_never_replays(engine, monkeypatch, size): + if blosc2.IS_WASM and size >= native._MINIMUM_PARALLEL_ITEMS: + pytest.skip("Large resident fast path requires host threads") + x = np.arange(size, dtype="int64") + original = native.prepare_resident + executed = [] + + class FailedSchedule: + def execute(self, *args, **kwargs): + executed.append(True) + raise ValueError("resident execution failed") + + def info(self): + return {"dtype": x.dtype, "shape": x.shape} + + def prepare(*args, **kwargs): + result = original(*args, **kwargs) + assert result is not None + return result[0], result[1], FailedSchedule() + + def forbidden(*args, **kwargs): + pytest.fail("Resident failure replayed through another execution route") + + monkeypatch.setattr(native, "prepare_resident", prepare) + monkeypatch.setattr(native, "compute_native_graph", forbidden) + monkeypatch.setattr(blosc2.LazyExpr, "_compute_expr", forbidden) + operation = ( + (lambda: blosc2.evaluate("x + 1", local_dict={"x": x})) + if engine == "evaluate" + else (lambda: blosc2.lazyexpr("x + 1", {"x": x})[:]) + ) + with pytest.raises(ValueError, match="resident execution failed"): + operation() + assert executed == [True] + + +@pytest.mark.parametrize("kind", ["overlap", "strided", "cast", "fortran"]) +@pytest.mark.parametrize("shape", [(4, 6), (1000, 1000)]) +def test_resident_explicit_output_preserves_contract(kind, shape): + x = np.arange(np.prod(shape), dtype="float64").reshape(shape) + if kind == "overlap": + out = x + elif kind == "strided": + out = np.empty((shape[0], shape[1] * 2))[:, ::2] + elif kind == "cast": + out = np.empty_like(x, dtype="float32") + else: + out = np.empty_like(x, order="F") + expected = np.broadcast_to(x + 1, out.shape).copy() + result = blosc2.evaluate("x + 1", local_dict={"x": x}, out=out) + assert result is out + np.testing.assert_array_equal(result, expected) + + +def test_resident_output_shape_failure_does_not_write(): + x = np.arange(6.0).reshape(1, 6) + out = np.full((4, 6), -1.0) + with pytest.raises(ValueError, match="output shape"): + blosc2.evaluate("x + 1", local_dict={"x": x}, out=out) + np.testing.assert_array_equal(out, -1) diff --git a/tests/test_schunk_insert.py b/tests/test_schunk_insert.py index aa1906cac..b366c9c20 100644 --- a/tests/test_schunk_insert.py +++ b/tests/test_schunk_insert.py @@ -5,29 +5,25 @@ # SPDX-License-Identifier: BSD-3-Clause ####################################################################### -import random - import numpy as np import pytest import blosc2 +from conftest import orthogonal_cases -@pytest.mark.parametrize("gil", [True, False]) -@pytest.mark.parametrize("contiguous", [True, False]) -@pytest.mark.parametrize("urlpath", [None, "b2frame"]) @pytest.mark.parametrize( - ("nchunks", "ninserts"), - [ - (0, 3), - (1, 1), - (10, 3), - (15, 17), - ], + ("storage_case", "counts", "gil"), + orthogonal_cases( + [(True, None), (False, None), (True, "b2frame"), (False, "b2frame")], + [(0, 3), (1, 1), (10, 3), (15, 17)], + [True, False], + ), ) -@pytest.mark.parametrize("copy", [True, False]) -@pytest.mark.parametrize("create_chunk", [True, False]) -def test_schunk_insert_numpy(contiguous, urlpath, nchunks, ninserts, copy, create_chunk, gil): +@pytest.mark.parametrize(("create_chunk", "copy"), [(True, True), (False, True), (False, False)]) +def test_schunk_insert_numpy(storage_case, counts, copy, create_chunk, gil): + contiguous, urlpath = storage_case + nchunks, ninserts = counts blosc2.set_releasegil(gil) storage = blosc2.Storage(contiguous=contiguous, urlpath=urlpath) blosc2.remove_urlpath(urlpath) @@ -35,13 +31,15 @@ def test_schunk_insert_numpy(contiguous, urlpath, nchunks, ninserts, copy, creat schunk = blosc2.SChunk( chunksize=200 * 1000 * 4, storage=storage, cparams={"nthreads": 2}, dparams={"nthreads": 2} ) + expected_chunks = [] for i in range(nchunks): buffer = i * np.arange(200 * 1000, dtype="int32") nchunks_ = schunk.append_data(buffer) assert nchunks_ == (i + 1) + expected_chunks.append(buffer.tobytes()) for i in range(ninserts): - pos = random.randint(0, nchunks + i) + pos = (0, nchunks + i, (nchunks + i) // 2)[i % 3] buffer = pos * np.arange(200 * 1000, dtype="int32") if create_chunk: chunk = blosc2.compress2(buffer) @@ -51,32 +49,30 @@ def test_schunk_insert_numpy(contiguous, urlpath, nchunks, ninserts, copy, creat chunk_ = schunk.decompress_chunk(pos) bytes_obj = buffer.tobytes() assert chunk_ == bytes_obj + expected_chunks.insert(pos, bytes_obj) dest = np.empty(buffer.shape, buffer.dtype) schunk.decompress_chunk(pos, dest) assert np.array_equal(buffer, dest) for i in range(nchunks + ninserts): - schunk.decompress_chunk(i) + assert schunk.decompress_chunk(i) == expected_chunks[i] assert gil == blosc2.set_releasegil(False) blosc2.remove_urlpath(urlpath) -@pytest.mark.parametrize("gil", [True, False]) -@pytest.mark.parametrize("contiguous", [True, False]) -@pytest.mark.parametrize("urlpath", [None, "b2frame"]) @pytest.mark.parametrize( - ("nchunks", "ninserts"), - [ - (0, 3), - (1, 1), - (10, 3), - (15, 17), - ], + ("storage_case", "counts", "gil"), + orthogonal_cases( + [(True, None), (False, None), (True, "b2frame"), (False, "b2frame")], + [(0, 3), (1, 1), (10, 3), (15, 17)], + [True, False], + ), ) -@pytest.mark.parametrize("copy", [True, False]) -@pytest.mark.parametrize("create_chunk", [True, False]) -def test_insert(contiguous, urlpath, nchunks, ninserts, copy, create_chunk, gil): +@pytest.mark.parametrize(("create_chunk", "copy"), [(True, True), (False, True), (False, False)]) +def test_insert(storage_case, counts, copy, create_chunk, gil): + contiguous, urlpath = storage_case + nchunks, ninserts = counts blosc2.set_releasegil(gil) storage = { "contiguous": contiguous, @@ -95,7 +91,7 @@ def test_insert(contiguous, urlpath, nchunks, ninserts, copy, create_chunk, gil) assert nchunks_ == (i + 1) for i in range(ninserts): - pos = random.randint(0, nchunks + i) + pos = (0, nchunks + i, (nchunks + i) // 2)[i % 3] bytes_obj = b"i " * nbytes if create_chunk: chunk = blosc2.compress2(bytes_obj, typesize=1) diff --git a/tests/test_schunk_update.py b/tests/test_schunk_update.py index 4115c6b0b..683cfdd07 100644 --- a/tests/test_schunk_update.py +++ b/tests/test_schunk_update.py @@ -5,28 +5,25 @@ # SPDX-License-Identifier: BSD-3-Clause ####################################################################### -import random - import numpy as np import pytest import blosc2 +from conftest import orthogonal_cases -@pytest.mark.parametrize("gil", [True, False]) -@pytest.mark.parametrize("contiguous", [True, False]) -@pytest.mark.parametrize("urlpath", [None, "b2frame"]) @pytest.mark.parametrize( - ("nchunks", "nupdates"), - [ - (0, 0), - (1, 1), - (7, 3), - ], + ("storage_case", "counts", "gil"), + orthogonal_cases( + [(True, None), (False, None), (True, "b2frame"), (False, "b2frame")], + [(7, 3), (1, 1), (0, 0)], + [True, False], + ), ) -@pytest.mark.parametrize("copy", [True, False]) -@pytest.mark.parametrize("create_chunk", [True, False]) -def test_schunk_update_numpy(contiguous, urlpath, nchunks, nupdates, copy, create_chunk, gil): +@pytest.mark.parametrize(("create_chunk", "copy"), [(True, True), (False, True), (False, False)]) +def test_schunk_update_numpy(storage_case, counts, copy, create_chunk, gil): + contiguous, urlpath = storage_case + nchunks, nupdates = counts blosc2.set_releasegil(gil) kwargs = { "contiguous": contiguous, @@ -37,14 +34,16 @@ def test_schunk_update_numpy(contiguous, urlpath, nchunks, nupdates, copy, creat blosc2.remove_urlpath(urlpath) schunk = blosc2.SChunk(chunksize=200 * 1000 * 4, **kwargs) + expected_chunks = [] for i in range(nchunks): buffer = i * np.arange(200 * 1000, dtype="int32") nchunks_ = schunk.append_data(buffer) assert nchunks_ == (i + 1) + expected_chunks.append(buffer.tobytes()) - for _ in range(nupdates): - pos = random.randint(0, nchunks - 1) - buffer = pos * np.arange(200 * 1000, dtype="int32") + for i in range(nupdates): + pos = (0, nchunks - 1, nchunks // 2)[i % 3] + buffer = (nchunks + i + 1) * np.arange(200 * 1000, dtype="int32") if create_chunk: chunk = blosc2.compress2(buffer) schunk.update_chunk(pos, chunk) @@ -52,6 +51,7 @@ def test_schunk_update_numpy(contiguous, urlpath, nchunks, nupdates, copy, creat schunk.update_data(pos, buffer, copy) chunk_ = schunk.decompress_chunk(pos) bytes_obj = buffer.tobytes() + expected_chunks[pos] = bytes_obj assert chunk_ == bytes_obj dest = np.empty(buffer.shape, buffer.dtype) @@ -59,24 +59,22 @@ def test_schunk_update_numpy(contiguous, urlpath, nchunks, nupdates, copy, creat assert np.array_equal(buffer, dest) for i in range(nchunks): - schunk.decompress_chunk(i) + assert schunk.decompress_chunk(i) == expected_chunks[i] blosc2.remove_urlpath(urlpath) -@pytest.mark.parametrize("gil", [True, False]) -@pytest.mark.parametrize("contiguous", [True, False]) -@pytest.mark.parametrize("urlpath", [None, "b2frame"]) @pytest.mark.parametrize( - ("nchunks", "nupdates"), - [ - (0, 0), - (1, 1), - (7, 3), - ], + ("storage_case", "counts", "gil"), + orthogonal_cases( + [(True, None), (False, None), (True, "b2frame"), (False, "b2frame")], + [(7, 3), (1, 1), (0, 0)], + [True, False], + ), ) -@pytest.mark.parametrize("copy", [True, False]) -@pytest.mark.parametrize("create_chunk", [True, False]) -def test_update(contiguous, urlpath, nchunks, nupdates, copy, create_chunk, gil): +@pytest.mark.parametrize(("create_chunk", "copy"), [(True, True), (False, True), (False, False)]) +def test_update(storage_case, counts, copy, create_chunk, gil): + contiguous, urlpath = storage_case + nchunks, nupdates = counts blosc2.set_releasegil(gil) kwargs = { "contiguous": contiguous, @@ -89,14 +87,16 @@ def test_update(contiguous, urlpath, nchunks, nupdates, copy, create_chunk, gil) nbytes = 23401 schunk = blosc2.SChunk(chunksize=nbytes * 2, **kwargs) + expected_chunks = [] for i in range(nchunks): bytes_obj = b"i " * nbytes nchunks_ = schunk.append_data(bytes_obj) assert nchunks_ == (i + 1) + expected_chunks.append(bytes_obj) - for _ in range(nupdates): - pos = random.randint(0, nchunks - 1) - bytes_obj = b"i " * nbytes + for i in range(nupdates): + pos = (0, nchunks - 1, nchunks // 2)[i % 3] + bytes_obj = bytes([65 + i]) * (nbytes * 2) if create_chunk: chunk = blosc2.compress2(bytes_obj, typesize=1) schunk.update_chunk(pos, chunk) @@ -104,9 +104,10 @@ def test_update(contiguous, urlpath, nchunks, nupdates, copy, create_chunk, gil) schunk.update_data(pos, bytes_obj, copy) res = schunk.decompress_chunk(pos) assert res == bytes_obj + expected_chunks[pos] = bytes_obj for i in range(nchunks): - schunk.decompress_chunk(i) + assert schunk.decompress_chunk(i) == expected_chunks[i] blosc2.remove_urlpath(urlpath) diff --git a/tests/test_storage_readers.py b/tests/test_storage_readers.py new file mode 100644 index 000000000..48d4aac8c --- /dev/null +++ b/tests/test_storage_readers.py @@ -0,0 +1,447 @@ +import numpy as np +import pytest + +import blosc2 +from blosc2.storage_readers import StorageReader, storage_reader_eligible +from conftest import orthogonal_cases + + +@pytest.fixture +def storage_runtime(): + if not getattr(blosc2.blosc2_ext, "native_array_sources_available", lambda: False)(): + pytest.skip("Native dependency does not provide bounded storage readers") + + +@pytest.fixture +def prefilter_runtime(storage_runtime): + if blosc2.IS_WASM: + pytest.skip("Native compressed prefilters are host-only; WASM uses bounded readers") + if not getattr(blosc2.blosc2_ext, "portable_prefilter_available", lambda: False)(): + pytest.skip("Native dependency does not provide portable prefilters") + + +def make_kernel(source="def k(x, y):\n return x + (y - 1)\n", inputs=None, output="float64", jit=True): + author = blosc2.DSLKernel.from_source(source) + return blosc2.PortableKernel.from_json( + author.export(inputs or {"x": "float64", "y": "float64"}, output), jit=jit + ) + + +@pytest.mark.parametrize("jit", [False, True]) +def test_bounded_full_reads(storage_runtime, jit, monkeypatch): + tile = 4096 + size = 3 * tile + 17 # Several full tiles plus a partial tail. + x_np, y_np = np.arange(size, dtype="float64"), np.ones(size) + x, y = blosc2.asarray(x_np), blosc2.asarray(y_np) + original = blosc2.NDArray.get_1d_span_numpy + requested = [] + + def bounded(self, array, chunk, start, count, **kwargs): + requested.append(count) + assert requested[-1] <= tile + return original(self, array, chunk, start, count, **kwargs) + + monkeypatch.setattr(blosc2.NDArray, "get_1d_span_numpy", bounded) + kernel = make_kernel(jit=jit) + values, report = kernel.evaluate_sources({"x": x, "y": y}, tile_items=tile, return_report=True) + np.testing.assert_array_equal(values, x_np + (y_np - 1)) + assert max(requested) == report["maximum_reader_items"] == tile + assert report["reader_bytes"] == x_np.nbytes + y_np.nbytes + assert report["temporary_bytes"] <= tile * 24 # two values plus logical indices + + +def test_lazy_and_compute_use_readers(storage_runtime, monkeypatch): + x_np = np.arange(200_000, dtype="float64") + x, y = blosc2.asarray(x_np, chunks=(8192,), blocks=(1024,)), np.ones(x_np.size) + kernel = make_kernel() + lazy = kernel.lazy({"x": x, "y": y}) + + def forbidden(*args, **kwargs): + pytest.fail("Original whole-partition block path used") + + monkeypatch.setattr(blosc2.PortableKernel, "evaluate_block", forbidden) + np.testing.assert_array_equal(lazy[:], x_np) + assert lazy._source_execution_report["maximum_reader_items"] <= 65536 + np.testing.assert_array_equal(lazy.compute(chunks=(8192,), blocks=(1024,))[:], x_np) + + +@pytest.mark.parametrize( + "item", + [ + (slice(1, 10, 2), slice(None, None, -2)), + (3, slice(2, 11)), + (slice(None), 1), + (slice(0, 0), slice(None)), + ], +) +def test_partial_broadcasting(storage_runtime, item): + x_np = np.arange(256.0).reshape(16, 16) + y_np = np.arange(16.0).reshape(1, 16) + kernel = make_kernel() + lazy = kernel.lazy({"x": blosc2.asarray(x_np), "y": blosc2.asarray(y_np)}) + np.testing.assert_array_equal(lazy[item], (x_np + (y_np - 1))[item]) + + +def test_strided_numpy_and_scalar_broadcast(storage_runtime): + x_np = np.arange(32.0).reshape(4, 8) + y_np = x_np[:, ::-1] + kernel = make_kernel() + np.testing.assert_array_equal( + kernel.lazy({"x": blosc2.asarray(x_np), "y": y_np})[::-1, ::2], + (x_np + (y_np - 1))[::-1, ::2], + ) + scalar = blosc2.asarray(np.array(2.0)) + np.testing.assert_array_equal(kernel.lazy({"x": scalar, "y": blosc2.asarray(y_np)})[:], 2 + y_np - 1) + + +def test_reader_error_not_replayed(storage_runtime, monkeypatch): + kernel = make_kernel() + x = blosc2.asarray(np.arange(200_000.0)) + lazy = kernel.lazy({"x": x, "y": x}) + calls = [] + original = StorageReader.read + + def failure(self, indices): + calls.append(True) + if len(calls) == 2: + raise OSError("Storage failed") + return original(self, indices) + + def forbidden(*args, **kwargs): + pytest.fail("Storage failure replayed through whole-partition execution") + + monkeypatch.setattr(StorageReader, "read", failure) + monkeypatch.setattr(blosc2.PortableKernel, "evaluate_block", forbidden) + with pytest.raises(OSError, match="Storage failed"): + lazy[::2] + assert len(calls) == 2 + + +def test_preflight_without_reads(storage_runtime, monkeypatch): + kernel = make_kernel() + x = blosc2.asarray(np.arange(4.0)) + + def forbidden(*args, **kwargs): + pytest.fail("Invalid request read storage") + + monkeypatch.setattr(StorageReader, "read", forbidden) + with pytest.raises(ValueError, match="broadcast domain"): + kernel.evaluate_sources({"x": x, "y": x}, shape=(8,)) + with pytest.raises(ValueError, match="tile_items"): + kernel.evaluate_sources({"x": x, "y": x}, tile_items=0) + + +def test_block_dependency_preserves_original_groups(storage_runtime): + kernel = make_kernel("def k(x):\n return x - block_sum(x)\n", {"x": "float64"}) + assert not storage_reader_eligible(kernel) + x = blosc2.asarray(np.arange(4.0)) + np.testing.assert_array_equal(kernel.lazy({"x": x})[:1], [-6]) + + +def test_context_and_final_cast_retain_original_path(storage_runtime): + cast = make_kernel("def k(x):\n return x\n", {"x": "float64"}, "int32") + assert not storage_reader_eligible(cast) + author = blosc2.DSLKernel.from_source("def k(x):\n return x + _i0\n") + context = blosc2.PortableKernel.from_json(author.export({"x": "float64"}, "float64", ndim=1)) + assert not storage_reader_eligible(context) + np.testing.assert_array_equal(context.lazy({"x": blosc2.asarray(np.ones(4))})[2:], [3, 4]) + + +def test_old_runtime_retains_existing_path(monkeypatch): + kernel = make_kernel(jit=False) + monkeypatch.setattr(blosc2.blosc2_ext, "native_array_sources_available", lambda: False, raising=False) + x = blosc2.asarray(np.arange(4.0)) + assert not storage_reader_eligible(kernel) + np.testing.assert_array_equal(kernel.lazy({"x": x, "y": x})[:], np.arange(4.0) * 2 - 1) + + +def test_weak_intermediates_keep_original_error_domain(storage_runtime): + kernel = make_kernel("def k(x):\n return x + (2 * 3)\n", {"x": "float64"}) + assert not storage_reader_eligible(kernel) + kernel = make_kernel("def k(x):\n return x + (1 + 2)\n", {"x": "int64"}, "int64") + assert not storage_reader_eligible(kernel) + + +def test_chunk_crossing_span(storage_runtime): + values = np.arange(10003.0) + x = blosc2.asarray(values, chunks=(3000,), blocks=(300,)) + kernel = make_kernel() + actual, report = kernel.evaluate_sources({"x": x, "y": x}, tile_items=4096, return_report=True) + np.testing.assert_array_equal(actual, values * 2 - 1) + assert report["maximum_reader_items"] == 4096 + + +@pytest.mark.parametrize("jit", [False, True]) +def test_numerical_status_matches_resident_tiles(storage_runtime, jit): + kernel = make_kernel("def k(x):\n return sqrt(x)\n", {"x": "float64"}, jit=jit) + values = np.linspace(-1, 1, 1001) + expected, resident = kernel.evaluate_array({"x": values}, tile_items=128, return_report=True) + actual, streamed = kernel.evaluate_sources( + {"x": blosc2.asarray(values)}, tile_items=128, return_report=True + ) + np.testing.assert_array_equal(actual, expected) + assert streamed["fp_flags"] == resident["fp_flags"] + assert streamed["fp_supported"] == resident["fp_supported"] + + +@pytest.mark.parametrize( + ("size", "dtype", "jit", "threads"), + orthogonal_cases([17, 257], ["float32", "float64"], [False, True], [1, 2, 12]), +) +def test_compute_returns_prefilter_output_without_numpy_staging( + prefilter_runtime, monkeypatch, size, dtype, jit, threads +): + values = np.arange(size, dtype=dtype) + x = blosc2.asarray(values, chunks=(128,), blocks=(32,)) + kernel = make_kernel(inputs={"x": dtype, "y": dtype}, output=dtype, jit=jit) + lazy = kernel.lazy({"y": x, "x": x}) # Binding order need not match signature order. + original = blosc2.NDArray.__getitem__ + + def forbidden(*args, **kwargs): + pytest.fail("Compute materialized a NumPy intermediate") + + with monkeypatch.context() as patch: + patch.setattr(blosc2.NDArray, "__getitem__", forbidden) + patch.setattr(lazy, "_values", forbidden) + patch.setattr(blosc2.PortableKernel, "evaluate_sources", forbidden) + result = lazy.compute(cparams={"clevel": 0, "nthreads": threads}) + second = lazy.compute(cparams={"clevel": 0, "nthreads": threads}) + assert isinstance(result, blosc2.NDArray) + assert result is not second + assert result.chunks == x.chunks + assert result.blocks == x.blocks + assert result.cparams.clevel == 0 + assert lazy._source_execution_report["route"] == "portable-prefilter" + assert lazy._source_execution_report["evaluated_blocks"] == (size + 31) // 32 + report = lazy._source_execution_report + assert report["threads"] == threads + assert 2 <= report["native_decoder_contexts"] <= threads * 2 + assert report["input_buffer_allocations"] == report["native_decoder_contexts"] + assert report["input_chunk_fetches"] == x.schunk.nchunks * 2 + padded_items = x.schunk.nchunks * x.chunks[0] - size + assert report["output_zero_fill_bytes"] == padded_items * result.dtype.itemsize + np.testing.assert_array_equal(original(result, slice(None)), values * 2 - 1) + tail = np.frombuffer(result.schunk.decompress_chunk(result.schunk.nchunks - 1), dtype=result.dtype) + live_items = size - (result.schunk.nchunks - 1) * result.chunks[0] + np.testing.assert_array_equal(tail[live_items:], 0) + + +@pytest.mark.parametrize("dtype", ["int16", "uint64"]) +def test_integer_literal_compute_uses_prefilter(prefilter_runtime, monkeypatch, dtype): + values = np.arange(1027, dtype=dtype) + if dtype == "int16": + values = values + np.int16(32000) + x = blosc2.asarray(values, chunks=(256,), blocks=(64,)) + native = make_kernel(inputs={"x": dtype, "y": dtype}, output=dtype) + assert storage_reader_eligible(native) + lazy = native.lazy({"x": x, "y": x}) + + def forbidden(*args, **kwargs): + pytest.fail("Integer compute replayed a logical group or staged NumPy input") + + with monkeypatch.context() as patch: + patch.setattr(lazy, "_values", forbidden) + patch.setattr(blosc2.NDArray, "__getitem__", forbidden) + result = lazy.compute(cparams={"codec": blosc2.Codec.LZ4, "clevel": 3, "nthreads": 2}) + np.testing.assert_array_equal(result[:], values + (values - 1)) + assert result.cparams.codec == blosc2.Codec.LZ4 + assert result.cparams.clevel == 3 + report = lazy._source_execution_report + assert report["route"] == "portable-prefilter" + assert report["evaluated_blocks"] == (values.size + 63) // 64 + assert report["input_chunk_fetches"] == x.schunk.nchunks * 2 + + +@pytest.mark.parametrize("jit", [False, True]) +@pytest.mark.parametrize("mixed", [False, True]) +def test_prefilter_direct_numpy_sink(prefilter_runtime, monkeypatch, jit, mixed): + bounds = np.iinfo("int64") + values = np.resize(np.array([bounds.min, bounds.max, 0, 1], dtype="int64"), 1027) + other = values[::-1].copy() + x = blosc2.asarray(values, chunks=(256,), blocks=(64,)) + y = other if mixed else blosc2.asarray(other, chunks=x.chunks, blocks=x.blocks) + native = make_kernel(inputs={"x": "int64", "y": "int64"}, output="int64", jit=jit) + guarded = np.full(values.size + 2, 123, dtype="int64") + output = guarded[1:-1] + + def forbidden(*args, **kwargs): + pytest.fail("Direct NumPy prefilter sink materialized a Blosc2 result") + + with monkeypatch.context() as patch: + patch.setattr(blosc2.NDArray, "__getitem__", forbidden) + for _ in range(2): + result, report = native._handle.evaluate_prefilter({"y": y, "x": x}, numpy_out=output) + assert result is output + np.testing.assert_array_equal(result, values + (other - 1)) + np.testing.assert_array_equal(guarded[[0, -1]], 123) + assert report["output_destination"] == "numpy" + assert report["output_zero_fill_bytes"] == 0 + assert report["evaluated_blocks"] == 17 + assert report["input_chunk_fetches"] == (5 if mixed else 10) + assert report["discarded_output_bytes"] < output.nbytes + + +def test_prefilter_numpy_sink_contract(prefilter_runtime): + values = np.arange(257.0) + x = blosc2.asarray(values, chunks=(128,), blocks=(32,)) + handle = make_kernel()._handle + inputs = {"x": x, "y": x} + with pytest.raises(ValueError, match="both"): + handle.evaluate_prefilter(inputs, out=x, numpy_out=values) + with pytest.raises(ValueError, match="shape and result dtype"): + handle.evaluate_prefilter(inputs, numpy_out=np.empty(257, dtype="int64")) + with pytest.raises(ValueError, match="shape and result dtype"): + handle.evaluate_prefilter(inputs, numpy_out=np.empty(256)) + for output in (np.empty(514)[::2], np.empty(257)): + output.flags.writeable = False + with pytest.raises(ValueError, match="writable, aligned and C-contiguous"): + handle.evaluate_prefilter(inputs, numpy_out=output) + with pytest.raises(ValueError, match="overlap"): + handle.evaluate_prefilter({"x": x, "y": values}, numpy_out=values) + assert not blosc2.blosc2_ext.portable_prefilter_inputs_eligible({"x": x, "y": values}) + + +def test_prefilter_numpy_small_chunks_and_failure_recovery(prefilter_runtime, monkeypatch): + values = np.arange(9.0) + x = blosc2.asarray(values, chunks=(4,), blocks=(2,)) + guarded = np.full(11, 123.0) + output = guarded[1:-1] + failing = make_kernel("def k(x):\n return x + (1 // 0)\n", {"x": "float64"}) + with pytest.raises(blosc2.PortableArtifactError, match="evaluation_error"): + failing._handle.evaluate_prefilter({"x": x}, numpy_out=output) + + def forbidden(*args, **kwargs): + pytest.fail("Small NumPy sink staged a Blosc2 result") + + with monkeypatch.context() as patch: + patch.setattr(blosc2.NDArray, "__getitem__", forbidden) + native = make_kernel() + result, report = native._handle.evaluate_prefilter({"x": x, "y": x}, numpy_out=output) + fresh, _ = native._handle.evaluate_prefilter({"x": x, "y": x}) + assert result is output + np.testing.assert_array_equal(result, values * 2 - 1) + np.testing.assert_array_equal(fresh, result) + np.testing.assert_array_equal(guarded[[0, -1]], 123) + assert report["output_zero_fill_bytes"] == 0 + + +def test_compute_prefilter_preserves_storage_options(prefilter_runtime, tmp_path): + values = np.arange(257.0) + x = blosc2.asarray(values, chunks=(128,), blocks=(32,)) + lazy = make_kernel().lazy({"x": x, "y": x}) + cparams = blosc2.CParams(clevel=5, nthreads=2) + path = tmp_path / "portable-compute.b2nd" + result = lazy.compute(cparams=cparams, urlpath=path, meta={"test": "direct"}) + assert cparams.nthreads == 2 # The caller's options are not mutated. + assert result.cparams.clevel == 5 + assert result.schunk.meta["test"] == "direct" + assert lazy._source_execution_report["output_zero_fill_bytes"] == x.schunk.nchunks * x.schunk.chunksize + np.testing.assert_array_equal(result[:], values * 2 - 1) + np.testing.assert_array_equal(blosc2.open(path)[:], values * 2 - 1) + + +@pytest.mark.parametrize("partial", [False, True]) +def test_compute_other_layouts_and_selections_keep_fallback(storage_runtime, partial): + values = np.arange(257.0) + x = blosc2.asarray(values, chunks=(128,), blocks=(32,)) + lazy = make_kernel().lazy({"x": x, "y": x}) + item = slice(3, 250, 2) if partial else None + result = lazy.compute(item=item, chunks=(64,), blocks=(16,), cparams={"clevel": 0}) + expected = values * 2 - 1 + np.testing.assert_array_equal(result[:], expected[item] if partial else expected) + assert result.chunks == (64,) + assert result.blocks == (16,) + assert lazy._source_execution_report["route"] == "bounded-readers" + + +def test_compute_prefilter_fp_status(storage_runtime): + values = np.linspace(-1, 1, 257) + x = blosc2.asarray(values, chunks=(128,), blocks=(32,)) + kernel = make_kernel("def k(x):\n return sqrt(x)\n", {"x": "float64"}) + expected, status = kernel.evaluate_array({"x": values}, tile_items=32, return_report=True) + lazy = kernel.lazy({"x": x}) + result = lazy.compute(cparams={"clevel": 0}) + np.testing.assert_array_equal(result[:], expected) + assert lazy._source_execution_report["fp_flags"] == status["fp_flags"] + assert lazy._source_execution_report["fp_supported"] == status["fp_supported"] + + +def test_prefilter_reuses_scratch_across_chunks_and_rebinding(prefilter_runtime): + values = np.arange(10003.0) + x = blosc2.asarray(values, chunks=(3000,), blocks=(300,)) + lazy = make_kernel().lazy({"x": x, "y": x}) + options = {"cparams": {"clevel": 0, "nthreads": 3}} + first = lazy.compute(**options) + np.testing.assert_array_equal(first[:], values * 2 - 1) + report = lazy._source_execution_report + assert report["evaluated_blocks"] == 34 + assert 2 <= report["native_decoder_contexts"] <= 6 + assert report["input_buffer_allocations"] == report["native_decoder_contexts"] + assert report["input_chunk_fetches"] == 8 + x[:] = values + 10 + second = lazy.compute(**options) + np.testing.assert_array_equal(second[:], (values + 10) * 2 - 1) + np.testing.assert_array_equal(first[:], values * 2 - 1) + + +@pytest.mark.parametrize("clevel", [0, 5]) +def test_prefilter_failure_is_raised_and_output_can_be_reused(prefilter_runtime, clevel): + # Call the native adapter directly to exercise worker failures. The Python + # lane-local gate intentionally excludes this checked weak-scalar operation. + failing = make_kernel("def k(x):\n return x + (1 // 0)\n", {"x": "float64"}) + x = blosc2.asarray(np.arange(257.0), chunks=(128,), blocks=(32,)) + output = blosc2.uninit( + x.shape, dtype=x.dtype, chunks=x.chunks, blocks=x.blocks, cparams={"clevel": clevel, "nthreads": 3} + ) + for _ in range(3): + with pytest.raises(blosc2.PortableArtifactError, match="evaluation_error"): + failing._handle.evaluate_prefilter({"x": x}, out=output) + healthy = make_kernel() + result, report = healthy._handle.evaluate_prefilter({"x": x, "y": x}, out=output) + assert result is output + assert report["evaluated_blocks"] == 9 + np.testing.assert_array_equal(result[:], np.arange(257.0) * 2 - 1) + + +@pytest.mark.parametrize("clevel", [0, 1, 5]) +def test_prefilter_incompressible_output_and_concurrent_calls(prefilter_runtime, clevel): + from concurrent.futures import ThreadPoolExecutor + + values = np.random.default_rng(42).normal(size=10003) + x = blosc2.asarray(values, chunks=(3000,), blocks=(300,)) + kernel = make_kernel() + + def compute(): + return kernel.lazy({"x": x, "y": x}).compute(cparams={"clevel": clevel, "nthreads": 3}) + + with ThreadPoolExecutor(max_workers=2) as pool: + results = list(pool.map(lambda _: compute(), range(4))) + for result in results: + np.testing.assert_array_equal(result[:], values + (values - 1)) + assert result.cparams.clevel == clevel + + +@pytest.mark.parametrize("clevel", [0, 1, 5]) +def test_compute_incompressible_output_on_all_runtimes(storage_runtime, clevel): + # Keep serial value/compression coverage on WASM as well as the host-only + # concurrent prefilter coverage above. + values = np.random.default_rng(42).normal(size=10003) + x = blosc2.asarray(values, chunks=(3000,), blocks=(300,)) + result = make_kernel().lazy({"x": x, "y": x}).compute(cparams={"clevel": clevel, "nthreads": 1}) + np.testing.assert_array_equal(result[:], values + (values - 1)) + assert result.cparams.clevel == clevel + + +def test_wasm_compute_keeps_bounded_reader_fallback(storage_runtime, monkeypatch): + values = np.arange(257.0) + x = blosc2.asarray(values, chunks=(128,), blocks=(32,)) + lazy = make_kernel(jit=False).lazy({"x": x, "y": x}) + + def forbidden(*args, **kwargs): + pytest.fail("Threadless WASM requested a host-only prefilter") + + monkeypatch.setattr(blosc2, "IS_WASM", True) + monkeypatch.setattr(blosc2.NDArray, "_execute_portable_prefilter", forbidden) + result = lazy.compute(chunks=(128,), blocks=(32,), cparams={"clevel": 0, "nthreads": 1}) + np.testing.assert_array_equal(result[:], values * 2 - 1) + assert lazy._source_execution_report["route"] == "bounded-readers" diff --git a/tools/menudet_arithmetic.py b/tools/menudet_arithmetic.py new file mode 100644 index 000000000..6f3718f8b --- /dev/null +++ b/tools/menudet_arithmetic.py @@ -0,0 +1,461 @@ +"""Pinned NumPy M3 reference vectors, retaining checked 1.0 corpus separately. + +Generate: python -m tools.menudet_arithmetic CORPUS_PATH +Run with tools.menudet_conformance run and an explicit native runner. +""" + +from __future__ import annotations + +import argparse +import json +import platform +import sys +from pathlib import Path + +import numpy as np + +from tools import menudet_conformance as compat + +DTYPES = ( + "bool", + "int8", + "int16", + "int32", + "int64", + "uint8", + "uint16", + "uint32", + "uint64", + "float32", + "float64", +) +OPERATORS = { + "add": ("+", np.add), + "subtract": ("-", np.subtract), + "multiply": ("*", np.multiply), + "divide": ("/", np.true_divide), + "floor-divide": ("//", np.floor_divide), + "remainder": ("%", np.remainder), + "power": ("**", np.power), + "bit-and": ("&", np.bitwise_and), + "bit-or": ("|", np.bitwise_or), + "bit-xor": ("^", np.bitwise_xor), + "shift-left": ("<<", np.left_shift), + "shift-right": (">>", np.right_shift), + "equal": ("==", np.equal), + "less": ("<", np.less), +} +OPERATORS.update( + { + "not-equal": ("!=", np.not_equal), + "less-equal": ("<=", np.less_equal), + "greater": (">", np.greater), + "greater-equal": (">=", np.greater_equal), + } +) + + +def recipe(expression, output): + if expression == "(x + 1) * 2": + return {"operation": "intermediate", "cast_to": output} + if expression == "x * y - 1": + return {"operation": "noncontracting", "cast_to": output} + for name, (spelling, _function) in OPERATORS.items(): + if expression == f"x {spelling} y": + return {"operation": name, "cast_to": output} + for expression_key, name in { + "+x": "positive", + "-x": "negative", + "~x": "invert", + "abs(x)": "absolute", + }.items(): + if expression == expression_key: + return {"operation": name, "cast_to": output} + for name, (spelling, _function) in OPERATORS.items(): + prefix = f"x {spelling} " + if expression.startswith(prefix): + literal = expression[len(prefix) :] + return { + "operation": name, + "literal": {"type": "float" if "." in literal else "int", "decimal": literal}, + "cast_to": output, + } + for dtype in DTYPES: + if expression == f"{dtype}(x)": + return {"operation": "identity", "cast_to": dtype} + if expression == "x": + return {"operation": "identity", "cast_to": output} + raise ValueError("No independent NumPy recipe for expression") + + +def reference_recipe(case): + arrays = [compat.checkpoint.decode(item) for item in case["inputs"]] + spec = case["numpy_recipe"] + with np.errstate(all="ignore"): + op = spec["operation"] + if op == "identity": + actual = arrays[0] + elif op == "intermediate": + actual = (arrays[0] + 1) * 2 + elif op == "noncontracting": + actual = arrays[0] * arrays[1] - 1 + elif op in {"positive", "negative", "absolute", "invert"}: + actual = getattr(np, op)(arrays[0]) + else: + literal = spec.get("literal") + if spec.get("captured_category"): + scalar = compat.checkpoint.decode(case["scalar_operands"][0])[()] + right = scalar.item() if spec["captured_category"] == "weak" else scalar + else: + right = ( + arrays[1] + if literal is None + else {"int": int, "float": float}[literal["type"]](literal["decimal"]) + ) + actual = OPERATORS[op][1](arrays[0], right) + if spec["cast_to"]: + actual = actual.astype(spec["cast_to"]) + return compat.describe(actual) + + +def make_case( + identifier, + arrays, + expression, + expected, + operation="identity", + output=None, + casting="unsafe", + diagnostic=None, +): + case = compat.make_case(identifier, "identity", "x", arrays, output=output) + artifact = json.loads(case["artifact"]) + names = [item["name"] for item in case["inputs"]] + artifact.update( + schema_version="1.0", + language={"name": "miniexpr", "version": "1.0"}, + source=f"def k({', '.join(names)}):\n return {expression}\n", + semantics={"fp": "strict", "numeric": "numpy-2.5", "casting": casting}, + ) + if expected is not None: + artifact["output"]["dtype"] = output or expected.dtype.name + case.update( + artifact=json.dumps(artifact, sort_keys=True), + semantic_revision="menudet-numpy-1.0", + operation=operation, + reference_kind="native-contract", + expected={"diagnostic": {"category": diagnostic}} if diagnostic else compat.describe(expected), + ) + if diagnostic is None: + case["inferred_dtype"] = arrays[0].dtype.name if output is not None else expected.dtype.name + case["numpy_recipe"] = recipe(expression, output) + case["reference_kind"] = "numpy" + if expected.dtype.kind == "f" and expression != "x": + case["comparison"]["nan"] = "equal" + return case + + +def generate(): # noqa: C901 -- explicit finite operator/promotion/cast matrix, no source evaluation + if np.__version__ != compat.checkpoint.REFERENCE: + raise RuntimeError("Generation requires pinned NumPy 2.5.3") + cases = [] + promotions = [] + cast_matrix = [] + with np.errstate(all="ignore"): + for left in DTYPES: + for right in DTYPES: + a = np.array([0, 1, 1], dtype=left) + b = np.array([1, 0, 1], dtype=right) + expected = np.add(a, b) + promotions.append({"left": left, "right": right, "dtype": np.result_type(a, b).name}) + cases.append(make_case(f"promotion-{left}-{right}", [a, b], "x + y", expected, "add")) + cases.append(make_case(f"compare-{left}-{right}", [a, b], "x == y", np.equal(a, b), "equal")) + for name, (spelling, function) in OPERATORS.items(): + if name in {"add", "equal"}: + continue + try: + expected = function(a, b) + diagnostic = None + except TypeError: + expected, diagnostic = None, "invalid_source" + cases.append( + make_case( + f"mixed-{left}-{right}-{name}", + [a, b], + f"x {spelling} y", + expected, + name, + diagnostic=diagnostic, + ) + ) + for dtype in DTYPES: + kind = np.dtype(dtype).kind + if kind == "b": + a, b = np.array([True, False, True]), np.array([True, True, False]) + elif kind in "iu": + info = np.iinfo(dtype) + a = np.array([info.min, info.max, 0, 1, 2, 3], dtype=dtype) + b = np.array([1, 2, 0, 0, 2, 3], dtype=dtype) + if kind == "i": + a[-2:] = [-7, -3] + b[-2:] = [3, -1] + else: + a = np.array([-7, -3, 0.0, -0.0, 0.1, 1], dtype=dtype) + b = np.array([3, -1, 0.0, 2, 0.1, 0.1], dtype=dtype) + for name, (spelling, function) in OPERATORS.items(): + try: + expected = function(a, b) + diagnostic = None + except (TypeError, ValueError): + expected, diagnostic = ( + None, + "invalid_source" if kind == "b" or kind == "f" else "evaluation_error", + ) + cases.append( + make_case( + f"operator-{dtype}-{name}", + [a, b], + f"x {spelling} y", + expected, + name, + diagnostic=diagnostic, + ) + ) + for name, spelling, function in [ + ("positive", "+x", np.positive), + ("negative", "-x", np.negative), + ("absolute", "abs(x)", np.absolute), + ("invert", "~x", np.invert), + ]: + try: + expected = function(a) + diagnostic = None + except TypeError: + expected, diagnostic = None, "invalid_source" + cases.append( + make_case(f"unary-{dtype}-{name}", [a], spelling, expected, name, diagnostic=diagnostic) + ) + if kind in "iu": + boundary_a = np.array([np.iinfo(dtype).min, 1, 0], dtype=dtype) + boundary_b = np.array([-1 if kind == "i" else 1, 0, 0], dtype=dtype) + for name, spelling, function in [ + ("floor", "//", np.floor_divide), + ("mod", "%", np.remainder), + ]: + cases.append( + make_case( + f"integer-divisor-boundary-{dtype}-{name}", + [boundary_a, boundary_b], + f"x {spelling} y", + function(boundary_a, boundary_b), + ) + ) + counts = np.array( + [0, 1, np.iinfo(dtype).bits - 1, np.iinfo(dtype).bits, np.iinfo(dtype).bits + 1, 127], + dtype=dtype, + ) + if kind == "i": + counts[-1] = -1 + for name, function, spelling in [ + ("left", np.left_shift, "<<"), + ("right", np.right_shift, ">>"), + ]: + cases.append( + make_case( + f"shift-boundary-{dtype}-{name}", + [a, counts], + f"x {spelling} y", + function(a, counts), + ) + ) + for literal in (1, 128, -1, 0.5): + try: + expected = np.add(a, literal) + diagnostic = None + except OverflowError: + expected, diagnostic = None, "invalid_source" + label = str(literal).replace("-", "negative-").replace(".", "point-") + cases.append( + make_case( + f"weak-{dtype}-{label}", [a], f"x + {literal}", expected, diagnostic=diagnostic + ) + ) + for name, spelling, function in [("equal", "==", np.equal), ("less", "<", np.less)]: + cases.append( + make_case( + f"weak-compare-{dtype}-{label}-{name}", + [a], + f"x {spelling} {literal}", + function(a, literal), + ) + ) + for source in DTYPES: + values = np.array([0, 1], dtype=source) + for target in DTYPES: + for policy in ("safe", "same_kind", "unsafe"): + allowed = bool(np.can_cast(source, target, casting=policy)) + cast_matrix.append({"from": source, "to": target, "policy": policy, "allowed": allowed}) + cases.append( + make_case( + f"cast-{source}-{target}-{policy.replace('_', '-')}", + [values], + "x", + values.astype(target) if allowed else None, + output=target, + casting=policy, + diagnostic=None if allowed else "binding_error", + ) + ) + for source in DTYPES[1:9]: + info = np.iinfo(source) + values = np.array([info.min, info.max, 0, 1], dtype=source) + for target in DTYPES: + cases.append( + make_case( + f"cast-boundary-{source}-{target}", + [values], + "x", + values.astype(target), + output=target, + ) + ) + cases.append( + make_case(f"explicit-{source}-{target}", [values], f"{target}(x)", values.astype(target)) + ) + for source in ("float32", "float64"): + values = np.array([-1.9, -0.0, 0.0, 1.9, 127.9], dtype=source) + for target in DTYPES: + # Negative -> unsigned, NaN/inf, and finite out-of-range conversion + # are deliberately defined diagnostics, not host sentinel goldens. + diagnostic = "evaluation_error" if target.startswith("uint") else None + cases.append( + make_case( + f"float-cast-{source}-{target}", + [values], + "x", + None if diagnostic else values.astype(target), + output=target, + diagnostic=diagnostic, + ) + ) + for target in DTYPES[1:9]: + case = make_case( + f"nonfinite-cast-{source}-{target}", + [np.array([np.nan, np.inf, -np.inf], dtype=source)], + "x", + None, + output=target, + diagnostic="evaluation_error", + ) + case["divergence"] = { + "id": "defined-float-cast", + "reason": "Reject unstable nonfinite/out-of-range floating-to-integer conversions instead of preserving a host-specific NumPy sentinel", + } + cases.append(case) + # Computation must wrap at int8 before conversion to a wider output. + a = np.array([127, -128], dtype="int8") + cases.append( + make_case( + "intermediate-not-output-driven", + [a], + "(x + 1) * 2", + ((a + 1) * 2).astype("int64"), + output="int64", + ) + ) + for dtype in DTYPES[1:9]: + maximum = np.iinfo(dtype).max + a, b = np.array([maximum, 2, 0], dtype=dtype), np.array([3, 10, 0], dtype=dtype) + cases.append(make_case(f"power-wrapping-{dtype}", [a, b], "x ** y", np.power(a, b))) + for left, right in [("int64", "uint64"), ("uint64", "int64")]: + a = np.array([2**63 - 1], dtype=left) + b = np.array([2**63 - 2], dtype=right) + cases.append(make_case(f"comparison-rounded-{left}-{right}", [a, b], "x == y", np.equal(a, b))) + from blosc2.portable_kernel import portable_scalar_descriptor + + for dtype in ("int8", "float32", "float64"): + a = np.array([0, 1, 2], dtype=dtype) + for label, scalar in [ + ("weak-int", 1), + ("weak-float", 0.5), + ("typed-int", np.int64(1)), + ("typed-float", np.float64(0.5)), + ("typed-float32", np.float32(0.5)), + ]: + expected = np.add(a, scalar) + case = make_case(f"capture-{dtype}-{label}", [a], "x + 1", expected) + artifact = json.loads(case["artifact"]) + category = "weak" if label.startswith("weak") else "typed_scalar" + artifact["source"] = "def k(x, c):\n return x + c\n" + artifact["constants"] = [{**portable_scalar_descriptor("c", scalar), "category": category}] + case["artifact"] = json.dumps(artifact, sort_keys=True) + case["scalar_operands"] = [compat.describe(np.asarray(scalar))] + case["numpy_recipe"] = {"operation": "add", "cast_to": None, "captured_category": category} + cases.append(case) + # Standard float divmod has correction beyond floor(x/y). + for dtype in ("float32", "float64"): + epsilon = np.finfo(dtype).eps + x, y = np.array([1 + epsilon], dtype=dtype), np.array([1 - epsilon], dtype=dtype) + cases.append(make_case(f"noncontracting-{dtype}", [x, y], "x * y - 1", x * y - 1)) + a = np.array([1, -1, 6, -6, np.inf, -np.inf, 0.0, -0.0, 3, -3], dtype=dtype) + b = np.array([0.1, 0.1, 0.1, 0.1, 3, 3, -3, 3, np.inf, np.inf], dtype=dtype) + for name, spelling, function in [("floor", "//", np.floor_divide), ("mod", "%", np.remainder)]: + case = make_case(f"float-divmod-{dtype}-{name}", [a, b], f"x {spelling} y", function(a, b)) + case["comparison"]["nan"] = "equal" + cases.append(case) + return { + "schema_version": compat.VERSION, + "generator_revision": "m3-1", + "reference": { + "numpy": np.__version__, + "intp_bits": np.dtype(np.intp).itemsize * 8, + "byteorder": sys.byteorder, + "platform": platform.platform(), + "machine": platform.machine(), + "floating_errors": "ignore", + "python": platform.python_version(), + }, + "provenance": {"checkpoint_schema": compat.VERSION, "rng": "NumPy PCG64", "seeds": []}, + "promotions": promotions, + "cast_matrix": cast_matrix, + "cases": cases, + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("corpus", type=Path) + args = parser.parse_args() + args.corpus.write_text(json.dumps(generate(), indent=2) + "\n") + + +def property_cases(seed, count=128): + """Full-width random bit patterns, not only small overflow-free operands.""" + rng = np.random.Generator(np.random.PCG64(seed)) + result = [] + operations = ( + "add", + "subtract", + "multiply", + "floor-divide", + "remainder", + "shift-left", + "shift-right", + "less", + ) + with np.errstate(all="ignore"): + for index in range(count): + dtype = np.dtype(DTYPES[1:9][index % 8]) + name = operations[(index // 8) % len(operations)] + spelling, function = OPERATORS[name] + arrays = [np.frombuffer(rng.bytes(dtype.itemsize * 16), dtype=dtype).copy() for _ in range(2)] + case = make_case( + f"arithmetic-property-{seed}-{index}", arrays, f"x {spelling} y", function(*arrays) + ) + case["seed"] = seed + result.append(case) + return result + + +if __name__ == "__main__": + main() diff --git a/tools/menudet_backend_bench.py b/tools/menudet_backend_bench.py new file mode 100644 index 000000000..75504a662 --- /dev/null +++ b/tools/menudet_backend_bench.py @@ -0,0 +1,227 @@ +"""M1 sign-off baselines: verified full-DSL TCC/GCC controls and portable interpreter. + +Every sample is a subprocess. Cold compilation, fresh-process disk reuse, +same-process recompilation, first evaluation and compiled warm execution are +separate. No user files/caches are removed; each trial gets an owned directory. +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import os +import platform +import shlex +import subprocess +import sys +import tempfile +import time +from pathlib import Path + +import numpy as np + + +def worker(engine, dtype, count, repeats): + import blosc2 + + numexpr = None + if engine == "numexpr": + try: + import numexpr + except ImportError: + return { + "requested": engine, + "backend": engine, + "status": "unavailable", + "reason": "NumExpr is optional", + } + x = np.arange(count, dtype=dtype) + compile_ns = 0 + if engine == "integrated": + artifact = json.dumps( + { + "schema_version": "1.0", + "language": {"name": "miniexpr", "version": "1.0"}, + "requires": ["numeric"], + "source": "def k(x):\n return x * 2 + 1\n", + "entry_point": "k", + "inputs": [{"name": "x", "dtype": dtype}], + "constants": [], + "output": {"dtype": dtype, "contract": "elementwise"}, + "semantics": {"fp": "strict"}, + "context": {"ndim": 0}, + "metadata": {}, + } + ) + start = time.perf_counter_ns() + kernel = blosc2.PortableKernel.from_json(artifact, jit=True) + compile_ns = time.perf_counter_ns() - start + if kernel.has_jit: + raise AssertionError("Update baseline eligibility before benchmarking a new portable JIT") + + def evaluate(): + return kernel.evaluate({"x": x}) + elif engine == "numpy": + + def evaluate(): + return x * 2 + 1 + else: + + def evaluate(): + return numexpr.evaluate("x * 2 + 1", local_dict={"x": x}) + + samples = [] + for _ in range(repeats + 1): + start = time.perf_counter_ns() + actual = evaluate() + samples.append(time.perf_counter_ns() - start) + np.testing.assert_array_equal(actual, x * 2 + 1) + assert actual.dtype == x.dtype + return { + "requested": engine, + "backend": "interpreter" if engine == "integrated" else engine, + "dtype": dtype, + "nitems": count, + "compile_ns": compile_ns, + "first_ns": samples[0], + "warm_median_ns": int(np.median(samples[1:])), + "numexpr_threads": numexpr.get_num_threads() if numexpr is not None else None, + "extension_sha256": hashlib.sha256(Path(blosc2.blosc2_ext.__file__).read_bytes()).hexdigest(), + } + + +def run(args): + root = args.work_dir.resolve() + root.mkdir(parents=True, exist_ok=True) + owned = Path(tempfile.mkdtemp(prefix="m1-baseline-", dir=root)) + log = owned / "compiler-invocations.txt" + wrapper = owned / "gcc-wrapper" + gcc_version = None + if args.gcc: + gcc_version = subprocess.check_output([str(args.gcc), "--version"], text=True).splitlines()[0] + if "clang" in gcc_version.lower(): + raise ValueError("--gcc must name actual GCC, not the macOS gcc alias to Clang") + wrapper.write_text( + f'#!/bin/sh\nprintf \'%s\\n\' "$*" >> {shlex.quote(str(log))}\nexec {shlex.quote(str(args.gcc.resolve()))} "$@"\n' + ) + wrapper.chmod(0o700) + environment = { + key: value + for key, value in os.environ.items() + if not key.startswith("ME_DSL_") and key not in {"CC", "CFLAGS"} + } + environment.update(ME_DSL_FP_MODE="strict", ME_DSL_JIT="1", CC=str(wrapper), NUMEXPR_NUM_THREADS="1") + backends = ["portable", "interpreter", "tcc", "integrated", "numpy", "numexpr"] + if args.gcc: + backends.append("cc") + rows = [] + + def compile_calls(): + return ( + sum("-dynamiclib" in line or "-shared" in line for line in log.read_text().splitlines()) + if log.exists() + else 0 + ) + + for trial in range(args.trials): + for dtype in ("float32", "float64", "int64"): + for count in (16, args.large_count): + order = backends if trial % 2 == 0 else list(reversed(backends)) + for backend in order: + cache = owned / f"trial-{trial}-{dtype}-{count}-{backend}" + cache.mkdir() + env = {**environment, "ME_DSL_JIT_CACHE_DIR": str(cache)} + native = backend in {"portable", "interpreter", "tcc", "cc"} + command = ( + [str(args.native_runner.resolve()), backend, dtype, str(count), str(args.repeats)] + if native + else [ + sys.executable, + str(Path(__file__).resolve()), + "--worker", + backend, + "--dtype", + dtype, + "--count", + str(count), + "--repeats", + str(args.repeats), + ] + ) + for phase in ["cold", "disk_cache_reuse"] if backend == "cc" else ["cold"]: + before = compile_calls() + start = time.perf_counter_ns() + proc = subprocess.run(command, env=env, capture_output=True, text=True, check=True) + process_ns = time.perf_counter_ns() - start + row = json.loads(proc.stdout) + row.update( + trial=trial, + phase=phase, + process_ns=process_ns, + compiler_invocations=compile_calls() - before, + route="direct_native" if native else "python", + ) + row["semantic_contract"] = ( + "full-miniexpr-control" + if backend in {"interpreter", "tcc", "cc"} + else "menudet-draft-1.0-checked" + if backend in {"portable", "integrated"} + else "control" + ) + if backend == "cc": + assert row["compiler_invocations"] == (1 if phase == "cold" else 0), row + row["compiler"] = gcc_version + rows.append(row) + return { + "schema_version": "menudet-backend-baseline-1", + "numpy": np.__version__, + "platform": platform.platform(), + "native_revision": args.native_revision, + "installed_native_revision": args.installed_native_revision, + "native_runner_sha256": hashlib.sha256(args.native_runner.read_bytes()).hexdigest(), + "gcc": gcc_version, + "trials": args.trials, + "repeats": args.repeats, + "owned_cache_directory": str(owned), + "order": "alternating forward/reverse subprocess order", + "results": rows, + "skips": ([] if args.gcc else [{"backend": "gcc", "reason": "No explicit GCC executable supplied"}]) + + [ + { + "backend": "tcc", + "phase": "disk_cache_reuse", + "reason": "TCC compiles in memory; no persistent disk artifact cache", + } + ], + "limitations": "Single host, affine positive-domain kernel only; native output preallocated, Python output allocated; no RSS/scaling claim.", + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--worker", choices=["integrated", "numpy", "numexpr"]) + parser.add_argument("--dtype", default="float64") + parser.add_argument("--count", type=int, default=16) + parser.add_argument("--repeats", type=int, default=3) + parser.add_argument("--trials", type=int, default=3) + parser.add_argument("--large-count", type=int, default=262144) + parser.add_argument("--native-runner", type=Path) + parser.add_argument("--gcc", type=Path) + parser.add_argument("--work-dir", type=Path) + parser.add_argument("--report", type=Path) + parser.add_argument("--native-revision") + parser.add_argument("--installed-native-revision") + args = parser.parse_args() + if not 1 <= args.repeats <= 101 or args.trials < 1: + parser.error("Positive trial count and 1..101 repetitions required") + if args.worker: + print(json.dumps(worker(args.worker, args.dtype, args.count, args.repeats))) + else: + if not args.native_runner or not args.work_dir or not args.report: + parser.error("--native-runner, --work-dir and --report are required") + args.report.write_text(json.dumps(run(args), indent=2) + "\n") + + +if __name__ == "__main__": + main() diff --git a/tools/menudet_batch_qualification.py b/tools/menudet_batch_qualification.py new file mode 100644 index 000000000..a2301cce0 --- /dev/null +++ b/tools/menudet_batch_qualification.py @@ -0,0 +1,85 @@ +"""Check exhaustive bulk-compiled corpus rows against the normal serial TCC route.""" + +import argparse +import hashlib +import json +import os +import re +import shutil +import subprocess +import time +from collections import Counter +from pathlib import Path +from tempfile import TemporaryDirectory + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("runner", type=Path) + parser.add_argument("corpus_directory", type=Path) + parser.add_argument("--report", type=Path, required=True) + args = parser.parse_args() + compilers = { + "tcc": None, + "gcc": os.environ.get("MENUDET_GCC", shutil.which("gcc-16")), + "clang": os.environ.get("MENUDET_CLANG", shutil.which("clang")), + } + if not compilers["gcc"] or not compilers["clang"]: + parser.error("GCC and Clang are required") + results = [] + for corpus in ("arithmetic-v1.0.json", "functions-v1.0.json"): + reference = None + for backend, compiler in compilers.items(): + with TemporaryDirectory(dir=os.environ["MENUDET_WORK_DIR"]) as cache: + environment = dict( + os.environ, ME_DSL_JIT_COMPILER="cc" if compiler else "tcc", ME_DSL_JIT_CACHE_DIR=cache + ) + environment.pop("MENUDET_JIT_SERIAL", None) + if compiler: + environment["CC"] = compiler + start = time.perf_counter() + process = subprocess.run( + [str(args.runner.resolve()), str((args.corpus_directory / corpus).resolve()), "on"], + env=environment, + capture_output=True, + text=True, + check=True, + timeout=60, + ) + elapsed = time.perf_counter() - start + rows = [json.loads(line) for line in process.stdout.splitlines()] + assert all(row["reference_match"] for row in rows) + if reference is None: + reference = rows + assert rows == reference, f"Complete conformance rows differ: {backend}/{corpus}" + bulk = re.search(r"bulk JIT: kernels=(\d+) compiler_invocations=(\d+) status=ok", process.stderr) + if compiler: + assert bulk is not None + assert int(bulk[2]) == 1 + assert int(bulk[1]) == sum(row["backend"] == "jit" for row in rows) + result = { + "corpus": corpus, + "backend": backend, + "cold_seconds": elapsed, + "cases": len(rows), + "routes": dict(Counter(row["backend"] for row in rows)), + "all_rows_identical_to_serial_tcc": True, + "external_compiler_invocations": int(bulk[2]) if bulk else 0, + "stdout_sha256": hashlib.sha256(process.stdout.encode()).hexdigest(), + } + results.append(result) + print(result, flush=True) + report = { + "method": "Fresh cache; all corpus rows compared exactly against serial TCC", + "results": results, + "compiler_versions": { + backend: subprocess.check_output([compiler, "--version"], text=True) + for backend, compiler in compilers.items() + if compiler + }, + } + args.report.write_text(json.dumps(report, indent=2) + "\n") + + +if __name__ == "__main__": + main() diff --git a/tools/menudet_conformance.py b/tools/menudet_conformance.py new file mode 100644 index 000000000..9f1e8bde0 --- /dev/null +++ b/tools/menudet_conformance.py @@ -0,0 +1,844 @@ +"""M2 shared, versioned conformance tooling (NumPy is generation tooling only). + +Use ``python -m tools.menudet_conformance``. Native corpus locations and executable +paths must be explicit. Generation/recording is separate from regression checking. +""" + +from __future__ import annotations + +import argparse +import copy +import hashlib +import json +import math +import platform +import subprocess +import tempfile +from pathlib import Path + +import numpy as np + +from tools import menudet_numpy_compat as checkpoint + +VERSION = "menudet-numpy-vectors-2" +CAPABILITIES = { + "numeric", + "control-flow", + "block-reductions", + "nd-context", + "fixed-strings", + "layout-copying", +} +STATUS = { + 0: "success", + -1: "invalid_artifact", + -2: "unsupported_requirement", + -3: "invalid_source", + -4: "binding_error", + -5: "evaluation_error", + -6: "out_of_memory", +} +BITWISE = {"kind": "bitwise", "atol": 0.0, "rtol": 0.0, "max_ulp": 0, "nan": "bits", "signed_zero": "exact"} + + +def describe(array, name=None, layout=None): + result = checkpoint.buffer(array, name) + if name is not None: + result["category"] = "zero_dimensional_array" if result["shape"] == [] else "array" + result["layout"] = layout or {"order": "C", "byteorder": "native", "step": 1, "reverse_axis": None} + if np.asarray(array).dtype.kind == "f": + result["classes"] = [ + "nan" + if np.isnan(x) + else "negative_inf" + if np.isneginf(x) + else "positive_inf" + if np.isposinf(x) + else "negative_zero" + if x == 0 and np.signbit(x) + else "positive_zero" + if x == 0 + else "subnormal" + if abs(x) < np.finfo(np.asarray(array).dtype).tiny + else "finite" + for x in np.asarray(array).ravel() + ] + return result + + +def decode(item): + """Reconstruct logical values in the declared physical layout, without eval.""" + array = checkpoint.decode(item) + layout = item.get("layout") + if not isinstance(layout, dict): + return array + if layout["order"] not in {"C", "F"} or layout["byteorder"] not in {"native", "little", "big"}: + raise ValueError("Invalid layout") + step = layout["step"] + if type(step) is not int or not 1 <= step <= 4: + raise ValueError("Invalid layout step") + axis = layout["reverse_axis"] + if axis is not None and (type(axis) is not int or not 0 <= axis < array.ndim): + raise ValueError("Invalid reverse axis") + dtype = array.dtype.newbyteorder({"native": "=", "little": "<", "big": ">"}[layout["byteorder"]]) + shape = list(array.shape) + if shape: + shape[-1] *= step + backing = np.zeros(shape, dtype=dtype, order=layout["order"]) + view = backing[..., ::step] if shape else backing + if axis is not None: + slices = [slice(None)] * view.ndim + slices[axis] = slice(None, None, -1) + view = view[tuple(slices)] + view[...] = array + return view + + +def ulp_distance(a, b, dtype): + unsigned = np.dtype("uint32" if np.dtype(dtype).itemsize == 4 else "uint64") + bits = unsigned.itemsize * 8 + sign = 1 << (bits - 1) + mask = (1 << bits) - 1 + + def ordered(value): + raw = int(np.asarray(value, dtype=dtype).view(unsigned)) + return (~raw & mask) if raw & sign else raw | sign + + return abs(ordered(a) - ordered(b)) + + +def compare(actual, expected, policy): + """Same comparison contract as the native runner, including special values.""" + if actual["dtype"] != expected["dtype"]: + return ["dtype"] + if actual["shape"] != expected["shape"]: + return ["shape"] + a, e = checkpoint.decode(actual).ravel(), checkpoint.decode(expected).ravel() + dtype = a.dtype + for index, (left, right) in enumerate(zip(a, e, strict=True)): + if dtype.kind != "f": + equal = left == right + elif np.isnan(left) or np.isnan(right): + equal = ( + np.isnan(left) + and np.isnan(right) + and ( + policy["nan"] == "equal" + or checkpoint.encode(np.asarray(left)) == checkpoint.encode(np.asarray(right)) + ) + ) + elif left == 0 and right == 0: + equal = policy["signed_zero"] == "ignore" or np.signbit(left) == np.signbit(right) + elif np.isinf(left) or np.isinf(right): + equal = left == right + elif policy["kind"] == "bitwise": + equal = checkpoint.encode(np.asarray(left)) == checkpoint.encode(np.asarray(right)) + elif policy["kind"] == "exact": + equal = left == right + elif policy["kind"] == "ulp": + equal = ulp_distance(left, right, dtype) <= policy["max_ulp"] + else: + equal = ( + abs(float(left) - float(right)) <= policy["atol"] + policy["rtol"] * abs(float(right)) + or ulp_distance(left, right, dtype) <= policy["max_ulp"] + ) + if not equal: + return [f"value:{index}"] + return [] + + +def classify(case, result): + if result.get("outcome") == "skipped": + return result + expected = case["expected"] + errors = ( + (["diagnostic"] if result["category"] != expected["diagnostic"]["category"] else []) + if "diagnostic" in expected + else ( + ["diagnostic"] if result["status"] else compare(result["output"], expected, case["comparison"]) + ) + ) + baseline = case.get("baseline") + regression = False + if baseline: + regression = result["status"] != baseline["status"] + if result["status"] == 0 and baseline["status"] == 0: + regression |= bool(compare(result["output"], baseline["output"], case["comparison"])) + result.update(reference_match=not errors, mismatches=errors, baseline_regression=regression) + result["outcome"] = ( + "regression" + if regression + else "known_divergence" + if errors and baseline and case.get("divergence") + else "mismatch" + if errors + else "matching" + ) + return result + + +def reference(case): + if case["reference_kind"] == "native-contract": + return case["expected"] + if "numpy_recipe" in case: + from tools.menudet_arithmetic import reference_recipe + + return reference_recipe(case) + if "function_recipe" in case: + from tools.menudet_functions import reference_recipe + + return reference_recipe(case) + arrays = [checkpoint.decode(item) for item in case["inputs"]] + literal = case.get("literal") + value = None if not literal else {"int": int, "float": float}[literal["type"]](literal["decimal"]) + if case.get("scalar_operands"): + value = checkpoint.decode(case["scalar_operands"][0])[()] + with np.errstate(all="ignore"): + try: + if case["operation"] == "identity": + actual = arrays[0] + elif case["operation"] in {"cos", "log", "sqrt", "exp"}: + actual = getattr(np, case["operation"])(arrays[0]) + elif case["operation"] == "sum": + actual = np.sum(arrays[0], dtype=np.dtype(json.loads(case["artifact"])["output"]["dtype"])) + else: + actual = checkpoint.reference(case["operation"], arrays, value) + except OverflowError: + return {"diagnostic": {"category": "invalid_source", "numpy_category": "OverflowError"}} + return describe(np.asarray(actual, dtype=json.loads(case["artifact"])["output"]["dtype"])) + + +def reference_expected(case): + """Select a reviewed, exact host observation, never the native baseline. + + NumPy's nonfinite-to-integer sentinel is explicitly platform-qualified in + the corpus. Native execution still must reject it with the recorded status; + only the independent NumPy drift check uses this host-specific observation. + Unlisted machines retain the original reference and therefore fail on drift. + """ + variants = case.get("reference_expected_by_machine", {}) + if variants and not case.get("platform_qualification"): + raise ValueError("Host reference variants require a platform qualification") + machine = platform.machine().lower() + machine = {"amd64": "x86_64", "aarch64": "arm64"}.get(machine, machine) + return variants.get(machine, case["expected"]) + + +def make_case( + identifier, operation, expression, arrays, output=None, literal=None, policy=None, layout=None +): + names = ["x", "y", "z"][: len(arrays)] + artifact = { + "schema_version": "1.0", + "language": {"name": "miniexpr", "version": "1.0"}, + "requires": ["numeric"], + "source": f"def k({', '.join(names)}):\n return {expression}\n", + "entry_point": "k", + "inputs": [{"name": n, "dtype": a.dtype.name} for n, a in zip(names, arrays, strict=True)], + "constants": [], + "output": {"dtype": output or arrays[0].dtype.name, "contract": "elementwise"}, + "semantics": {"fp": "strict", "numeric": "numpy-2.5", "casting": "unsafe"}, + "context": {"ndim": 0}, + "metadata": {}, + } + case = { + "id": identifier, + "operation": operation, + "semantic_revision": "menudet-numpy-1.0", + "requires": ["numeric"], + "artifact": json.dumps(artifact, sort_keys=True), + "inputs": [describe(a, n, layout) for n, a in zip(names, arrays, strict=True)], + "scalar_operands": [], + "literal": None + if literal is None + else {"category": "weak", "type": type(literal).__name__, "decimal": str(literal)}, + "comparison": policy or copy.deepcopy(BITWISE), + "reference_kind": "numpy", + "seed": None, + } + case["expected"] = reference(case) + return case + + +def generate(checkpoint_path): + if np.__version__ != checkpoint.REFERENCE: + raise RuntimeError("Generation requires NumPy 2.5.3") + previous = json.loads(checkpoint_path.read_text()) + if checkpoint.reference_drift(previous)["differences"]: + raise ValueError("Pinned reference has drifted; do not silently regenerate") + cases = [] + for original in previous["cases"]: + case = copy.deepcopy(original) + case.update(reference_kind="numpy", seed=None, comparison=copy.deepcopy(BITWISE)) + case["inputs"] = [describe(checkpoint.decode(item), item["name"]) for item in original["inputs"]] + case["expected"] = describe(checkpoint.decode(original["expected"])) + if case["id"] == "float64-cast-infinity": + # Exact observations from the pinned NumPy ARM64 and x64 builds; + # keep the native diagnostic/divergence baseline unchanged. + case["reference_expected_by_machine"] = { + machine: {**case["expected"], "hex": bits} + for machine, bits in {"x86_64": "8000000000000000", "arm64": "7fffffffffffffff"}.items() + } + case["scalar_operands"] = copy.deepcopy(original.get("scalar_operands", [])) + old = case["baseline"] + case["baseline"] = {"status": old["status"], "category": STATUS[old["status"]]} + if old["status"] == 0: + case["baseline"]["output"] = { + "dtype": json.loads(case["artifact"])["output"]["dtype"], + "shape": original["inputs"][0]["shape"], + "encoding": "raw-be-hex", + "hex": old["hex"], + } + if original["classification"] == "divergent": + case["divergence"] = { + "id": "checkpoint-" + original["id"], + "reason": "Reviewed current draft divergence; see native checkpoint divergence register", + } + cases.append(case) + for dtype in ("float32", "float64"): + for operation in ("sin", "cos", "log", "sqrt", "exp"): + values = np.array([0.125, 0.5, 1, 2, 8], dtype=dtype) + cases.append( + make_case( + f"{dtype}-{operation}-finite-ulp", + operation, + f"{operation}(x)", + [values], + policy={**BITWISE, "kind": "ulp", "max_ulp": 2, "nan": "equal"}, + ) + ) + special = np.array( + [ + 0.0, + -0.0, + np.inf, + -np.inf, + np.nan, + np.nextafter(np.array(0, dtype=dtype), np.array(1, dtype=dtype)), + ], + dtype=dtype, + ) + cases.append(make_case(f"{dtype}-identity-special", "identity", "x", [special])) + cases.append( + make_case( + f"{dtype}-sqrt-domain", + "sqrt", + "sqrt(x)", + [np.array([-1, -0.0, 4, np.inf, np.nan], dtype=dtype)], + policy={**BITWISE, "kind": "exact", "nan": "equal"}, + ) + ) + payload = "7fc01234ffc05678" if dtype == "float32" else "7ff8000000001234fff8000000005678" + values = checkpoint.decode({"dtype": dtype, "shape": [2], "hex": payload}) + cases.append(make_case(f"{dtype}-nan-payload-identity", "identity", "x", [values])) + cases.append( + make_case( + "float64-exp-tolerance", + "exp", + "exp(x)", + [np.array([-1, 0, 1], dtype="float64")], + policy={**BITWISE, "kind": "tolerance", "atol": 1e-15, "rtol": 1e-15, "nan": "equal"}, + ) + ) + for label, layout in [ + ("fortran", {"order": "F", "byteorder": "native", "step": 1, "reverse_axis": None}), + ("negative-stride", {"order": "C", "byteorder": "native", "step": 1, "reverse_axis": 0}), + ("stepped-big-endian", {"order": "F", "byteorder": "big", "step": 2, "reverse_axis": 1}), + ("little-endian", {"order": "C", "byteorder": "little", "step": 1, "reverse_axis": None}), + ]: + cases.append( + make_case( + f"layout-{label}", + "identity", + "x", + [np.arange(6, dtype="float32").reshape(2, 3)], + layout=layout, + ) + ) + cases.append(make_case("empty-elementwise", "identity", "x", [np.empty((2, 0), dtype="int64")])) + cases.append( + make_case("weak-scalar-out-of-range", "add", "x + 128", [np.array([1], dtype="int8")], literal=128) + ) + # Native validation/binding contracts are not represented as NumPy arithmetic. + for label, change, diagnostic in [ + ("future-artifact", "schema_version", "unsupported_requirement"), + ("invalid-source", "source", "invalid_source"), + ("wrong-binding", "binding", "binding_error"), + ]: + case = make_case(f"diagnostic-{label}", "identity", "x", [np.array([1], dtype="int64")]) + artifact = json.loads(case["artifact"]) + if change == "schema_version": + artifact[change] = "9.0" + elif change == "source": + artifact[change] = "def k(x):\n return missing_name\n" + else: + artifact["inputs"][0]["dtype"] = "float64" + case.update( + artifact=json.dumps(artifact, sort_keys=True), + reference_kind="native-contract", + expected={"diagnostic": {"category": diagnostic}}, + ) + cases.append(case) + recovery = make_case( + "failure-then-success-same-handle", "add", "x + 1", [np.array([127], dtype="int8")], literal=1 + ) + recovery["divergence"] = {"id": "D01", "reason": "Checked integer overflow instead of NumPy wrapping"} + recovery["recovery"] = { + "inputs": [describe(np.array([1], dtype="int8"), "x")], + "expected": describe(np.array([2], dtype="int8")), + } + cases.append(recovery) + reduced = make_case( + "block-sum-explicit-int64", "sum", "block_sum(x)", [np.arange(6, dtype="int64").reshape(2, 3)] + ) + artifact = json.loads(reduced["artifact"]) + artifact["requires"].append("block-reductions") + artifact["output"]["contract"] = "block_scalar" + reduced.update(artifact=json.dumps(artifact, sort_keys=True), requires=["numeric", "block-reductions"]) + cases.append(reduced) + complex_case = make_case( + "capability-complex-skipped", "identity", "x", [np.array([1 + 2j], dtype="complex64")] + ) + complex_case["requires"] = ["numpy-complex"] + complex_case["skip_reason"] = ( + "Complex numerical semantics are explicitly outside the current native capability set" + ) + cases.append(complex_case) + broadcast = make_case( + "capability-broadcast-skipped", + "add", + "x + y", + [np.array([[1], [2]], dtype="float32"), np.array([[2, 3, 4]], dtype="float32")], + ) + broadcast.update( + requires=["numeric", "array-broadcasting"], + skip_reason="Native array broadcasting is milestone 5, not an implemented kernel capability", + ) + cases.append(broadcast) + # Stable minimized property regression, independently replayed by the fuzz command. + minimized = make_case( + "seed-1729-minimized-int8-overflow", + "add", + "x + y", + [np.array([127], dtype="int8"), np.array([1], dtype="int8")], + ) + minimized.update( + seed=1729, + minimized_from="seeded boundary property", + divergence={"id": "D01", "reason": "Checked integer overflow instead of NumPy wrapping"}, + ) + cases.append(minimized) + return { + "schema_version": VERSION, + "generator_revision": "m2-1", + "reference": previous["reference"], + "provenance": { + "checkpoint_schema": previous["schema_version"], + "rng": "NumPy PCG64", + "seeds": [1729], + }, + "cases": cases, + } + + +def validate(corpus): + """Bounded execution schema checks; JSON Schema is also checked in natively.""" + if corpus.get("schema_version") != VERSION or not corpus.get("cases"): + raise ValueError("Unsupported or empty vector schema") + ids = set() + for case in corpus["cases"]: + identifier = case["id"] + if ( + not identifier + or any(c not in "abcdefghijklmnopqrstuvwxyz0123456789-" for c in identifier) + or identifier in ids + ): + raise ValueError("Invalid or duplicate case ID") + ids.add(identifier) + if case["semantic_revision"] != "menudet-numpy-1.0": + raise ValueError("Unsupported semantic revision") + policy = case["comparison"] + if ( + policy["kind"] not in {"bitwise", "exact", "ulp", "tolerance"} + or policy["nan"] not in {"bits", "equal"} + or policy["signed_zero"] not in {"exact", "ignore"} + ): + raise ValueError("Invalid comparison policy") + if ( + any(not math.isfinite(policy[key]) or policy[key] < 0 for key in ("atol", "rtol")) + or type(policy["max_ulp"]) is not int + or not 0 <= policy["max_ulp"] <= 2**64 - 1 + ): + raise ValueError("Invalid comparison threshold") + if not isinstance(case["requires"], list) or any( + not isinstance(cap, str) + or not cap + or any(c not in "abcdefghijklmnopqrstuvwxyz0123456789-:._" for c in cap) + for cap in case["requires"] + ): + raise ValueError("Invalid capabilities") + for item in case["inputs"]: + if ( + len(item["shape"]) > 8 + or any(type(dim) is not int or not 0 <= dim <= 4096 for dim in item["shape"]) + or math.prod(item["shape"]) > 4096 + ): + raise ValueError("Invalid input extent") + # Unknown capabilities skip execution but never excuse corrupt transport. + if ( + item["encoding"] != "raw-be-hex" + or len(bytes.fromhex(item["hex"])) + != math.prod(item["shape"]) * np.dtype(item["dtype"]).itemsize + ): + raise ValueError("Invalid input encoding") + decode(item) + + +def integrate(corpus, jit=False): # noqa: C901 -- paired execution, diagnostics, status and recovery checks + import blosc2 + + validate(corpus) + results = [] + for case in corpus["cases"]: + unsupported = sorted(set(case["requires"]) - CAPABILITIES) + if unsupported: + results.append( + { + "id": case["id"], + "outcome": "skipped", + "backend": "none", + "skipped_capabilities": unsupported, + "skip_reason": case.get("skip_reason", "unsupported required capability"), + } + ) + continue + kernel = None + actual = None + recovery_ok = True + try: + kernel = blosc2.PortableKernel.from_json(case["artifact"], jit=jit) + for _ in range(3): + current = kernel.evaluate( + {item["name"]: decode(item) for item in case["inputs"]}, + return_status="fp_expected" in case, + ) + if "fp_expected" in case: + current, fp_status = current + assert not fp_status["supported"] or fp_status["flags"] == case["fp_expected"], case[ + "id" + ] + if actual is not None: + assert checkpoint.encode(current) == checkpoint.encode(actual), case["id"] + actual = current + result = {"id": case["id"], "status": 0, "category": "success", "output": describe(actual)} + if case.get("inferred_dtype"): + assert kernel.inferred_dtype == np.dtype(case["inferred_dtype"]), case["id"] + except blosc2.PortableArtifactError as error: + status = next(code for code, category in STATUS.items() if category == error.status) + # Replay the failure through the same owned handle when one was loaded. + if kernel is not None: + for _ in range(2): + try: + kernel.evaluate({item["name"]: decode(item) for item in case["inputs"]}) + except blosc2.PortableArtifactError as again: + if again.status != error.status or again.native_status != error.native_status: + raise AssertionError("Repeated diagnostic changed") from again + else: + raise AssertionError("A repeated failure changed its diagnostic") from error + result = { + "id": case["id"], + "status": status, + "category": error.status, + "native_status": error.native_status, + } + if case.get("recovery"): + if kernel is None: + raise AssertionError("Recovery requires a compiled handle") + recovery = case["recovery"] + recovered = kernel.evaluate({item["name"]: decode(item) for item in recovery["inputs"]}) + recovery_ok = not compare(describe(recovered), recovery["expected"], case["comparison"]) + assert recovery_ok, case["id"] + result.update( + backend="jit" if kernel and kernel.has_jit else "interpreter" if kernel else "none", + requested_backend="jit" if jit else "interpreter", + jit_eligible=bool(kernel and kernel.has_jit), + jit_skip_reason="" + if kernel and kernel.has_jit + else "no compiled route for this artifact/request", + recovery_ok=recovery_ok, + ) + results.append(classify(case, result)) + return results + + +def native(corpus, runner, work_dir, jit=False, observe=False): + validate(corpus) + # Close the input before launching the native reader. Windows cannot reopen + # a live NamedTemporaryFile with its default delete/share mode. + with tempfile.TemporaryDirectory(dir=work_dir) as directory: + path = Path(directory) / "corpus.json" + path.write_text(json.dumps(corpus)) + command = [str(runner.resolve()), str(path), "on" if jit else "off"] + ( + ["observe"] if observe else [] + ) + proc = subprocess.run(command, capture_output=True, text=True, check=False) + rows = [json.loads(line) for line in proc.stdout.splitlines()] + if len(rows) != len(corpus["cases"]): + raise AssertionError(f"Native runner did not report every case: {proc.stderr}") + if proc.returncode and not any( + row.get("outcome") in {"mismatch", "regression"} + or not row.get("environment_restored", True) + or not row.get("recovery_ok", True) + for row in rows + ): + raise AssertionError(f"Invalid native vector or runner failure: {proc.stderr}") + return rows + + +def paired(corpus, runner, work_dir, observe=False): + validate(corpus) + reports = {} + for jit in (False, True): + c_results = native(corpus, runner, work_dir, jit, observe) + p_results = integrate(corpus, jit) + for case, c, p in zip(corpus["cases"], c_results, p_results, strict=True): + assert case["id"] == c["id"] == p["id"] + if p["outcome"] == "skipped": + assert c["outcome"] == "skipped", (c, p) + assert c["skipped_capabilities"] == p["skipped_capabilities"] + continue + assert c["status"] == p["status"], (c, p) + assert c["backend"] == p["backend"], (c, p) + assert c["reference_match"] == p["reference_match"], (c, p) + assert c["outcome"] == p["outcome"], (c, p) + assert c["environment_restored"] + assert c["recovery_ok"] + assert p["recovery_ok"] + if not c["status"]: + assert not compare(c["output"], p["output"], case["comparison"]), (c, p) + reports["on" if jit else "off"] = {"native": c_results, "python": p_results} + drift = [] + for case in corpus["cases"]: + actual = reference(case) + expected = reference_expected(case) + mismatch = ( + actual != expected + if "diagnostic" in expected + else bool(compare(actual, expected, case["comparison"])) + ) + if mismatch: + drift.append({"id": case["id"], "actual": actual}) + import blosc2 + + try: + git = subprocess.run( + ["git", "rev-parse", "HEAD"], + cwd=Path(__file__).resolve().parents[1], + capture_output=True, + text=True, + check=False, + ) + python_revision = git.stdout.strip() if git.returncode == 0 else None + except OSError: + python_revision = None + return { + "schema_version": "menudet-conformance-report-2", + "provenance": { + "python_revision": python_revision, + "runner_sha256": hashlib.sha256(runner.read_bytes()).hexdigest(), + "extension_sha256": hashlib.sha256(Path(blosc2.blosc2_ext.__file__).read_bytes()).hexdigest(), + "package": blosc2.__file__, + "generator_revision": corpus["generator_revision"], + "corpus_sha256": hashlib.sha256(json.dumps(corpus, sort_keys=True).encode()).hexdigest(), + "semantic_revisions": sorted({case["semantic_revision"] for case in corpus["cases"]}), + "local_changes": "Menudet 1.0 NumPy arithmetic, signatures, floating status and optional JIT", + }, + "reference_numpy": corpus["reference"]["numpy"], + "installed_numpy": np.__version__, + "installed_machine": platform.machine(), + "reference_drift": drift, + "eligible_jit_cases": sum(bool(row.get("jit_eligible")) for row in reports["on"]["native"]), + "requests": reports, + } + + +def check(report): + bad = [ + (request, engine, row["id"], row["outcome"]) + for request, engines in report["requests"].items() + for engine, rows in engines.items() + for row in rows + if row["outcome"] in {"mismatch", "regression"} + ] + if bad or report["reference_drift"]: + raise AssertionError( + f"Unexpected conformance failures: {bad}; reference drift: {report['reference_drift']}" + ) + + +def record(corpus, report): + for case, c, _p in zip( + corpus["cases"], + report["requests"]["off"]["native"], + report["requests"]["off"]["python"], + strict=True, + ): + if c["outcome"] == "skipped": + continue + if c.get("baseline_regression"): + raise AssertionError(f"Existing baseline changed: {case['id']}; review it separately") + if not c["reference_match"] and not case.get("divergence"): + raise AssertionError(f"Unreviewed divergence: {case['id']}; do not turn it into golden data") + case["baseline"] = {"status": c["status"], "category": c["category"]} + if not c["status"]: + case["baseline"]["output"] = c["output"] + case["classification"] = "matching" if c["reference_match"] else "divergent" + + +def property_cases(seed, count=48): + rng = np.random.Generator(np.random.PCG64(seed)) + result = [] + for index in range(count): + dtype = ("int8", "int16", "float32", "float64")[index % 4] + arrays = [rng.integers(-30, 31, size=8).astype(dtype) for _ in range(2)] + case = make_case(f"property-{seed}-{index}", "add", "x + y", arrays) + case["seed"] = seed + result.append(case) + boundary = make_case( + f"property-{seed}-boundary", + "add", + "x + y", + [np.array([0, 127, 2], dtype="int8"), np.array([0, 1, 2], dtype="int8")], + ) + # Strong int8 addition wraps in Menudet 1.0, just as in NumPy. This is a + # boundary regression, not a known checked-arithmetic divergence. + boundary["seed"] = seed + result.append(boundary) + return result + + +def minimized_failure(case, fails): # noqa: C901 -- bounded delta-debugging plus scalar shrinking + """Deterministic lane delta-debugging and scalar shrinking; no source eval.""" + result = copy.deepcopy(case) + + def candidate(arrays): + current = copy.deepcopy(result) + current.pop("baseline", None) + current["inputs"] = [ + describe(array, item["name"]) for array, item in zip(arrays, result["inputs"], strict=True) + ] + current["expected"] = reference(current) + return current + + arrays = [checkpoint.decode(item).ravel() for item in result["inputs"]] + if not fails(result): + raise ValueError("Cannot minimize a passing case") + size = len(arrays[0]) + granularity = 2 + while size > 1: + changed = False + for indices in np.array_split(np.arange(size), min(size, granularity)): + trial_arrays = [array[indices] for array in arrays] + trial = candidate(trial_arrays) + if fails(trial): + result, arrays, size = trial, trial_arrays, len(indices) + changed = True + granularity = 2 + break + if not changed: + if granularity >= size: + break + granularity = min(size, granularity * 2) + for array_index, array in enumerate(arrays): + for index in range(len(array)): + integral = array.dtype.kind in "iub" + value = int(array[index]) if integral else float(array[index]) + options = [0, 1, -1] + if math.isfinite(value): + options.append((value // 2 if value >= 0 else -((-value) // 2)) if integral else value / 2) + if value > 0: + options.append(value - 1) + elif value < 0: + options.append(value + 1) + for option in sorted(set(options), key=abs): + if abs(option) >= abs(value): + continue + if integral: + lower, upper = ( + (0, 1) + if array.dtype.kind == "b" + else (np.iinfo(array.dtype).min, np.iinfo(array.dtype).max) + ) + if not lower <= option <= upper: + continue + trial_arrays = [a.copy() for a in arrays] + trial_arrays[array_index][index] = option + trial = candidate(trial_arrays) + if fails(trial): + result, arrays = trial, trial_arrays + value = option + result["minimized_from"] = case["id"] + return result + + +def properties(corpus, runner, work_dir, seeds): + summaries = [] + for seed in seeds: + generated = {**corpus, "cases": property_cases(seed)} + observed = paired(generated, runner, work_dir, observe=True) + check(observed) + rows = observed["requests"]["off"]["native"] + failures = [ + case for case, row in zip(generated["cases"], rows, strict=True) if not row["reference_match"] + ] + if failures: + raise AssertionError(f"New seeded failure: {seed}: {failures}") + summaries.append( + { + "seed": seed, + "cases": len(rows), + "matching": len(rows) - len(failures), + "known_divergences": len(failures), + "minimized": None, + "promoted_case_id": "seed-1729-minimized-int8-overflow" if seed == 1729 else None, + } + ) + return {"rng": "PCG64", "seeds": seeds, "results": summaries} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("action", choices=["generate", "record", "run", "properties"]) + parser.add_argument("corpus", type=Path) + parser.add_argument("--checkpoint", type=Path) + parser.add_argument("--native-runner", type=Path) + parser.add_argument("--work-dir", type=Path, required=True) + parser.add_argument("--report", type=Path) + parser.add_argument("--seed", type=int, action="append") + args = parser.parse_args() + args.work_dir.mkdir(parents=True, exist_ok=True) + if args.action == "generate": + if args.checkpoint is None: + parser.error("--checkpoint is required for explicit checkpoint migration") + args.corpus.write_text(json.dumps(generate(args.checkpoint), indent=2) + "\n") + return + if args.native_runner is None: + parser.error("--native-runner is required") + corpus = json.loads(args.corpus.read_text()) + if args.action == "properties": + report = properties(corpus, args.native_runner, args.work_dir, args.seed or [1729, 20261009]) + else: + report = paired(corpus, args.native_runner, args.work_dir, observe=args.action == "record") + if args.action == "record": + record(corpus, report) + args.corpus.write_text(json.dumps(corpus, indent=2) + "\n") + report = paired(corpus, args.native_runner, args.work_dir) + check(report) + if args.report: + args.report.write_text(json.dumps(report, indent=2) + "\n") + else: + print(json.dumps(report, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/tools/menudet_functions.py b/tools/menudet_functions.py new file mode 100644 index 000000000..b9304ad22 --- /dev/null +++ b/tools/menudet_functions.py @@ -0,0 +1,595 @@ +"""Generate M4 native-owned signatures, accuracy and exceptional-value vectors.""" + +from __future__ import annotations + +import argparse +import json +import math +from pathlib import Path + +import numpy as np + +from tools import menudet_arithmetic as arithmetic +from tools import menudet_conformance as compat + +UNARY = { + name: name + for name in ( + "sin", + "cos", + "tan", + "sinh", + "cosh", + "tanh", + "sqrt", + "cbrt", + "exp", + "exp2", + "expm1", + "log", + "log2", + "log10", + "log1p", + "ceil", + "floor", + "trunc", + "rint", + "round", + "sign", + "square", + "conj", + "real", + "imag", + "isfinite", + "isinf", + "isnan", + "signbit", + "fabs", + "absolute", + ) +} +UNARY.update( + { + "abs": "absolute", + "ln": "log", + "acos": "arccos", + "asin": "arcsin", + "atan": "arctan", + "acosh": "arccosh", + "asinh": "arcsinh", + "atanh": "arctanh", + } +) +BINARY = { + name: name + for name in ( + "minimum", + "maximum", + "fmin", + "fmax", + "hypot", + "copysign", + "nextafter", + "logaddexp", + "fmod", + "remainder", + "power", + "ldexp", + ) +} +BINARY.update({"atan2": "arctan2", "pow": "power"}) + +REMOVED_ALIASES = ("arccos", "arccosh", "arcsin", "arcsinh", "arctan", "arctan2", "arctanh") +EXTRA = ( + "erf", + "erfc", + "lgamma", + "tgamma", + "exp10", + "sinpi", + "cospi", + "fdim", + "fma", + "fac", + "ncr", + "npr", + "e", + "pi", +) +EXACT = { + "where", + "ceil", + "floor", + "trunc", + "rint", + "round", + "sign", + "square", + "conj", + "real", + "imag", + "isfinite", + "isinf", + "isnan", + "signbit", + "fabs", + "absolute", + "abs", + "minimum", + "maximum", + "fmin", + "fmax", + "copysign", + "nextafter", + "ldexp", + "fac", + "ncr", + "npr", + "e", + "pi", + "fma", + "fmod", + "remainder", +} + + +def reference_values(name, arrays): # noqa: C901 -- explicit extension contracts, no source execution + with np.errstate(all="ignore"): + if name in UNARY: + return np.asarray(getattr(np, UNARY[name])(arrays[0])) + if name in BINARY: + actual = np.asarray(getattr(np, BINARY[name])(*arrays)) + if name in {"minimum", "maximum", "fmin", "fmax"} and actual.dtype.kind == "f": + ties = (arrays[0] == 0) & (arrays[1] == 0) + negative = ( + (np.signbit(arrays[0]) | np.signbit(arrays[1])) + if name in {"minimum", "fmin"} + else (np.signbit(arrays[0]) & np.signbit(arrays[1])) + ) + actual[ties] = np.copysign(0, np.where(negative[ties], -1, 1)) + return actual + if name == "where": + return np.where(*arrays) + # Extensions have explicit native contracts rather than disguised NumPy goldens. + dtype = arrays[0].dtype + if name in {"fac", "ncr", "npr"} and dtype.kind == "b": + dtype = np.dtype("int64") + elif name == "fma": + dtype = np.dtype("float32" if dtype.name == "float32" else "float64") + elif name not in {"fac", "ncr", "npr", "e", "pi"} and dtype.kind in "iub": + dtype = np.dtype("float32" if dtype.itemsize == 2 else "float64") + if name in {"e", "pi"}: + return np.full(arrays[0].shape, getattr(math, name), dtype="float64") + if name in {"fac", "ncr", "npr"}: + function = {"fac": math.factorial, "ncr": math.comb, "npr": math.perm}[name] + return np.array( + [function(*(int(a[i]) for a in arrays)) for i in range(arrays[0].size)], dtype=dtype + ) + if name == "fma": + values = [] + for i in range(arrays[0].size): + try: + values.append(math.fma(*(float(a[i]) for a in arrays))) + except ValueError: + values.append(np.nan) + except OverflowError: + values.append(np.copysign(np.inf, float(arrays[0][i]) * float(arrays[1][i]))) + return np.array(values, dtype=dtype) + if name == "fdim": + a, b = [x.astype(dtype) for x in arrays] + result = np.zeros_like(a) + selected = a > b + result[selected] = a[selected] - b[selected] + result[np.isnan(a) | np.isnan(b)] = np.nan + return result + if name == "exp10": + return np.power(np.array(10, dtype=dtype), arrays[0]) + if name in {"sinpi", "cospi"}: + import mpmath as mp + + with mp.workdps(100): + function = mp.sinpi if name == "sinpi" else mp.cospi + result = np.array([float(function(float(x))) for x in arrays[0]], dtype=dtype) + if name == "sinpi": + zeros = result == 0 + result[zeros] = np.copysign(0, arrays[0][zeros]) + return result + function = {"tgamma": math.gamma}.get(name, getattr(math, name, None)) + values = [] + for x in arrays[0]: + try: + values.append(function(float(x))) + except ValueError: + values.append(np.inf if name == "lgamma" else np.copysign(np.inf, x) if x == 0 else np.nan) + except OverflowError: + values.append(np.inf) + return np.array(values, dtype=dtype) + + +def reference_recipe(case): + return compat.describe( + reference_values(case["function_recipe"], [compat.checkpoint.decode(x) for x in case["inputs"]]) + ) + + +def make_case(identifier, name, arrays, expected=None, diagnostic=None): + identifier = identifier.replace("_", "-") + count = 0 if name in {"pi", "e"} else len(arrays) + expression = f"{name}({', '.join(('x', 'y', 'z')[:count])})" + case = compat.make_case( + identifier, + "identity", + "x", + arrays, + output=(expected.dtype.name if expected is not None else "float64"), + ) + artifact = json.loads(case["artifact"]) + artifact.update( + schema_version="1.0", + language={"name": "miniexpr", "version": "1.0"}, + source=f"def k({', '.join(x['name'] for x in case['inputs'])}):\n return {expression}\n", + semantics={"fp": "strict", "numeric": "numpy-2.5", "casting": "unsafe"}, + ) + case.update( + artifact=json.dumps(artifact, sort_keys=True), + operation=name, + semantic_revision="menudet-numpy-1.0", + reference_kind="numpy" if diagnostic is None and name not in EXTRA else "native-contract", + ) + if diagnostic: + case["expected"] = {"diagnostic": {"category": diagnostic}} + else: + case["function_recipe"] = name + case["expected"] = compat.describe(expected) + case["inferred_dtype"] = expected.dtype.name + case["comparison"]["nan"] = "equal" + if ( + name in {"minimum", "maximum", "fmin", "fmax"} + and expected is not None + and expected.dtype.kind == "f" + ): + case["reference_kind"] = "native-contract" + case["divergence"] = { + "id": "ieee-extrema-zero", + "reason": "Signed-zero ties use deterministic IEEE minimum/maximum; NumPy tie results vary by loop/platform", + } + if name not in EXACT: + case["comparison"].update(kind="ulp", max_ulp=8) + return case + + +def generate(): # noqa: C901 -- enumerated signatures, domains, exceptions and status vectors + if np.__version__ != compat.checkpoint.REFERENCE: + raise RuntimeError("Function generation requires pinned NumPy 2.5.3") + cases, signatures = [], [] + for name in (*UNARY, *BINARY): + for dtype in arithmetic.DTYPES: + a = np.array([0, 1, 2], dtype=dtype) + arrays = ( + [a] + if name in UNARY + else [a, np.array([1, 1, 2], dtype="int32" if name == "ldexp" else dtype)] + ) + try: + expected = reference_values(name, arrays) + diagnostic = "invalid_source" if expected.dtype.name == "float16" else None + except (TypeError, ValueError): + expected, diagnostic = None, "invalid_source" + signatures.append( + { + "function": name, + "inputs": [x.dtype.name for x in arrays], + "result": expected.dtype.name if expected is not None else None, + "supported": diagnostic is None, + "reason": diagnostic, + } + ) + cases.append( + make_case( + f"signature-{name}-{dtype}", + name, + arrays, + expected if not diagnostic else None, + diagnostic, + ) + ) + for name in EXTRA: + for dtype in arithmetic.DTYPES: + a = np.ones(2, dtype=dtype) + arrays = [a] + if name in {"fdim", "fma", "ncr", "npr"}: + arrays.append(a.copy()) + if name == "fma": + arrays.append(a.copy()) + diagnostic = None + if name in {"fac", "ncr", "npr"} and a.dtype.kind == "f": + diagnostic = "invalid_source" + if name not in {"fac", "ncr", "npr", "e", "pi", "fma"} and dtype in {"bool", "int8", "uint8"}: + diagnostic = "invalid_source" + expected = None if diagnostic else reference_values(name, arrays) + signatures.append( + { + "function": name, + "inputs": [x.dtype.name for x in arrays], + "result": None if expected is None else expected.dtype.name, + "supported": diagnostic is None, + "reason": diagnostic, + "reference_kind": "native-contract", + } + ) + cases.append( + make_case(f"signature-extension-{name}-{dtype}", name, arrays, expected, diagnostic) + ) + for dtype in arithmetic.DTYPES: + arrays = [ + np.array([True, False, True]), + np.array([0, 1, 2], dtype=dtype), + np.array([2, 1, 0], dtype=dtype), + ] + expected = reference_values("where", arrays) + signatures.append( + { + "function": "where", + "inputs": [a.dtype.name for a in arrays], + "result": dtype, + "supported": True, + "reason": None, + } + ) + cases.append(make_case(f"signature-where-{dtype}", "where", arrays, expected)) + for dtype in ("float32", "float64"): + info = np.finfo(dtype) + # Signed zeros, normal/subnormal boundaries, NaNs, infinities, domain edges. + a = np.array( + [ + -np.inf, + -info.max, + -2, + -1, + -0.5, + -0.0, + 0.0, + info.smallest_subnormal, + info.tiny, + 0.5, + 1, + 2, + info.max, + np.inf, + np.nan, + ], + dtype=dtype, + ) + b = np.array( + [ + np.nan, + 0, + 0, + 2, + -0.0, + 0.0, + -0.0, + info.tiny, + info.smallest_subnormal, + 2, + -1, + np.inf, + -info.max, + np.inf, + np.nan, + ], + dtype=dtype, + ) + for name in (*UNARY, *BINARY): + arrays = [a] if name in UNARY else [a, b] + if name == "ldexp": + arrays = [ + a, + np.array([-2000, 2000, -1, 0, 1, 0, 0, -1, -1, 1, 2000, 2000, 1, 0, 0], dtype="int32"), + ] + cases.append( + make_case(f"exceptional-{name}-{dtype}", name, arrays, reference_values(name, arrays)) + ) + for name in ("rint", "round"): + values = np.array([-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5], dtype=dtype) + cases.append(make_case(f"ties-{name}-{dtype}", name, [values], reference_values(name, [values]))) + for name in EXTRA: + arrays = [np.array([0.25, 0.5, 1, 2], dtype=dtype)] + if name in {"fac", "ncr", "npr"}: + arrays = [np.array([1, 2, 3, 4], dtype="int64")] + if name in {"fdim", "fma", "ncr", "npr"}: + arrays.append(np.ones(4, dtype=arrays[0].dtype)) + if name == "fma": + arrays.append(-np.ones(4, dtype=dtype)) + cases.append( + make_case(f"extension-{name}-{dtype}", name, arrays, reference_values(name, arrays)) + ) + if name not in {"fac", "ncr", "npr", "e", "pi"}: + inputs = [a] + if name in {"fdim", "fma"}: + inputs.append(b) + if name == "fma": + inputs.append(np.zeros_like(a)) + cases.append( + make_case( + f"extension-exceptional-{name}-{dtype}", name, inputs, reference_values(name, inputs) + ) + ) + for name in ("fac", "ncr", "npr"): + arrays = [np.array([-1, 0, 30], dtype="int64")] + if name != "fac": + arrays.append(np.array([1, 1, 15], dtype="int64")) + cases.append(make_case(f"extension-domain-{name}", name, arrays, diagnostic="evaluation_error")) + cases.append( + make_case( + f"extension-float-reject-{name}", + name, + [x.astype("float64") for x in arrays], + diagnostic="invalid_source", + ) + ) + for dtype in ("float32", "float64"): + cond = np.array([True, False, True]) + arrays = [cond, np.array([1, np.nan, -0.0], dtype=dtype), np.array([np.nan, 2, 0.0], dtype=dtype)] + cases.append(make_case(f"where-{dtype}", "where", arrays, reference_values("where", arrays))) + # Values and reporting must be independent of the caller's current IEEE flags. + for label, expression, values, expected, flags in [ + ("invalid", "sqrt(x)", [-1.0], [np.nan], 1), + ("divide", "log(x)", [0.0], [-np.inf], 2), + ("overflow", "exp(x)", [1000.0], [np.inf], 4), + ("underflow", "exp(x)", [-1000.0], [0.0], 8), + ("clear", "sqrt(x)", [4.0], [2.0], 0), + ("lazy-where", "where(x > 0, sqrt(x), 0)", [-1.0, 4.0], [0.0, 2.0], 0), + ]: + case = make_case(f"status-{label}", "sqrt", [np.array(values)], np.array(expected)) + artifact = json.loads(case["artifact"]) + artifact["source"] = f"def k(x):\n return {expression}\n" + case.update( + artifact=json.dumps(artifact, sort_keys=True), + fp_expected=flags, + reference_kind="native-contract", + ) + case.pop("function_recipe", None) + if label == "lazy-where": + case["divergence"] = { + "id": "lazy-where", + "reason": "Only selected lanes are evaluated, unlike eager NumPy argument evaluation", + } + cases.append(case) + for name in (*UNARY, *BINARY, *EXTRA, "where"): + arity = ( + 0 + if name in {"e", "pi"} + else 3 + if name in {"fma", "where"} + else 2 + if name in BINARY or name in {"fdim", "ncr", "npr"} + else 1 + ) + case = make_case(f"arity-reject-{name}", name, [np.array([1.0])], diagnostic="invalid_source") + artifact = json.loads(case["artifact"]) + artifact["source"] = f"def k(x):\n return {name}({', '.join(['x'] * (arity + 1))})\n" + case["artifact"] = json.dumps(artifact, sort_keys=True) + cases.append(case) + for name in ("float_power", "logaddexp2", "heaviside", "spacing", "frexp", "modf", *REMOVED_ALIASES): + arrays = [np.array([1.0])] * (2 if name == "arctan2" else 1) + cases.append(make_case(f"spelling-reject-{name}", name, arrays, diagnostic="invalid_source")) + certified = certified_cases() + cases.extend(certified) + metadata = arithmetic.generate() + return { + **{k: v for k, v in metadata.items() if k not in {"cases", "promotions", "cast_matrix"}}, + "generator_revision": "m4-2-canonical-inverse-trig", + "signatures": signatures, + "cases": cases, + "certification": { + "reference": "mpmath", + "decimal_precision": 100, + "seed": 20261009, + "cases": len(certified), + "samples_per_case": 32, + "max_ulp": 8, + }, + "unsupported_spellings": [ + *REMOVED_ALIASES, + "fmin.reduce", + "maximum.reduce", + "float_power", + "logaddexp2", + "heaviside", + "spacing", + "frexp", + "modf", + ], + "divergences": { + "where": "lazy selected-lane evaluation", + "round": "one argument; decimals not implemented", + "float16": "NumPy loops producing float16 reject", + "extensions": "libm/native names without NumPy equivalents use explicit contracts", + }, + } + + +def certified_cases(): + """Independent finite-reference samples; bounded accuracy, not a proof over R.""" + import mpmath as mp + + functions = { + name: getattr(mp, name) + for name in ( + "sqrt", + "exp", + "expm1", + "log", + "log10", + "log1p", + "sin", + "cos", + "tan", + "asin", + "acos", + "atan", + "sinh", + "cosh", + "tanh", + "asinh", + "acosh", + "atanh", + "erf", + "erfc", + "sinpi", + "cospi", + ) + } + functions.update( + exp2=lambda x: mp.power(2, x), + exp10=lambda x: mp.power(10, x), + log2=lambda x: mp.log(x, 2), + cbrt=lambda x: mp.sign(x) * mp.root(abs(x), 3), + lgamma=lambda x: mp.log(abs(mp.gamma(x))), + tgamma=mp.gamma, + hypot=lambda x, y: mp.sqrt(x * x + y * y), + atan2=mp.atan2, + logaddexp=lambda x, y: mp.log(mp.exp(x) + mp.exp(y)), + fma=lambda x, y, z: x * y + z, + ) + rng = np.random.Generator(np.random.PCG64(20261009)) + cases = [] + with mp.workdps(100): + for dtype in ("float32", "float64"): + for name, function in functions.items(): + values = rng.uniform(-0.8, 0.8, 32) + if name in {"sqrt", "log", "log2", "log10", "lgamma", "tgamma", "logaddexp"}: + values = rng.uniform(0.1, 8, 32) + if name == "acosh": + values = rng.uniform(1, 8, 32) + arrays = [values.astype(dtype)] + if name in {"hypot", "atan2", "logaddexp", "fma"}: + arrays.append(rng.uniform(0.1, 8, 32).astype(dtype)) + if name == "fma": + arrays.append(rng.uniform(-0.8, 0.8, 32).astype(dtype)) + expected = np.array( + [float(function(*(mp.mpf(float(a[i])) for a in arrays))) for i in range(32)], dtype=dtype + ) + case = make_case(f"certified-{name}-{dtype}", name, arrays, expected) + case.update( + reference_kind="native-contract", + seed=20261009, + certification={"reference": "mpmath-100-dps", "max_ulp": 8}, + ) + case.pop("function_recipe", None) + if name != "fma": + case["comparison"].update(kind="ulp", max_ulp=8) + cases.append(case) + return cases + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("corpus", type=Path) + args = parser.parse_args() + args.corpus.write_text(json.dumps(generate(), indent=2) + "\n") + + +if __name__ == "__main__": + main() diff --git a/tools/menudet_graph_bench.py b/tools/menudet_graph_bench.py new file mode 100644 index 000000000..5bf0f2e9f --- /dev/null +++ b/tools/menudet_graph_bench.py @@ -0,0 +1,275 @@ +"""Isolated M5/M6 performance evidence, not a universal speed budget.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import os +import platform +import statistics +import subprocess +import sys +import time +from pathlib import Path + +import numpy as np + +import blosc2 +from blosc2.native_graph import compile_plan + +try: + import resource +except ImportError: + resource = None + + +def peak_rss_bytes(): + """Return peak resident memory, or None when the platform cannot report it.""" + if resource is None: + return None + rss = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss + return rss if sys.platform == "darwin" else rss * 1024 + + +def timed(call): + start = time.perf_counter_ns() + result = call() + return result, (time.perf_counter_ns() - start) / 1e6 + + +def worker(size, dtype, route, layout, reduction): # noqa: C901 -- isolated benchmark routes + x = np.linspace(0, 1, size, dtype=dtype) + if layout == "strided": + x = np.repeat(x, 2)[::2] + # Keep comparison semantics common to every route. + source = "x * 2 + 1" + shape = (size,) + expr = None + compile_ms = None + if route in {"native", "graph", "blosc2"}: + with blosc2.expression_evaluation("safe"): + expr = blosc2.lazyexpr(source, {"x": x}) + if route in {"native", "graph"}: + compile_plan.cache_clear() + plan, compile_ms = timed(expr.native_kernel) + build = time.perf_counter_ns() + if route == "native": + bound = {name: value for name, value in expr.operands.items() if name in plan.input_dtypes} + + def call(): + return plan.evaluate_array(bound, reduction="sum" if reduction else None, return_report=True) + elif route == "graph": + + def call(): + return ( + expr.sum(_require_native=True) + if reduction + else expr.compute(_require_native=True, _getitem=True) + ) + elif route == "blosc2": + + def call(): + return expr.sum() if reduction else expr[:] + elif route == "numpy": + + def call(): + return np.sum(x * 2 + 1) if reduction else x * 2 + 1 + elif route == "numexpr": + try: + import numexpr + except ImportError: + return { + "route": route, + "size": size, + "dtype": dtype, + "layout": layout, + "reduction": reduction, + "status": "unavailable", + "reason": "NumExpr is an optional external reference", + } + + numexpr.set_num_threads(1) + + def call(): + return numexpr.evaluate("sum(x * 2 + 1)" if reduction else source, local_dict={"x": x}) + else: + raise ValueError(route) + setup_ms = (time.perf_counter_ns() - build) / 1e6 + first, first_ms = timed(call) + warm = [timed(call)[1] for _ in range(5)] + native_report = first[1] if route == "native" else getattr(expr, "_native_execution_report", None) + values = first[0] if route == "native" else first + reference = np.sum(x * 2 + 1) if reduction else x * 2 + 1 + np.testing.assert_allclose(values, reference, rtol=1e-3 if reduction else 1e-6) + return { + "route": route, + "size": size, + "dtype": dtype, + "layout": layout, + "reduction": reduction, + "compile_ms": compile_ms, + "setup_ms": setup_ms, + "first_ms": first_ms, + "warm_median_ms": statistics.median(warm), + "peak_rss_bytes": peak_rss_bytes(), + "native_report": native_report, + "shape": shape, + "backend": "portable-interpreter" if route in {"native", "graph"} else route, + "threads": 1, + "iterator_tile_items": 1024, + "numpy": np.__version__, + "package": blosc2.__file__, + } + + +def supplement(scenario): + from concurrent.futures import ThreadPoolExecutor + from tempfile import TemporaryDirectory + + x = np.linspace(0, 1, 8192, dtype="float64") + with TemporaryDirectory(dir=os.environ.get("MENUDET_WORK_DIR")) as directory: + root = Path(directory) + operands = {"x": x} + expression = "x * 2 + 1" + reference = x * 2 + 1 + if scenario == "mixed": + operands = {"x": x.astype("float32"), "y": np.ones(1, dtype="float64")} + expression = "x + y" + reference = operands["x"] + operands["y"] + if scenario in {"compressed", "persisted"}: + operands["x"] = blosc2.asarray(x, urlpath=root / "input.b2nd", chunks=(1024,), blocks=(256,)) + with blosc2.expression_evaluation("safe"): + expr = blosc2.lazyexpr(expression, operands) + plan, compile_ms = timed(expr.native_kernel) + if scenario == "partial": + + def call(): + return expr.compute(slice(128, 2048, 2), _require_native=True, _getitem=True) + + reference = reference[128:2048:2] + elif scenario == "persisted": + bindings = {n: v for n, v in expr.operands.items() if n in plan.input_dtypes} + portable = plan.lazy(bindings, partitions=(1024,)) + portable.save(root / "recipe.b2nd") + loaded, load_ms = timed(lambda: blosc2.open(root / "recipe.b2nd", deserialize="safe")) + + def call(): + return loaded[:] + elif scenario == "threaded": + bindings = {n: v for n, v in expr.operands.items() if n in plan.input_dtypes} + pool = ThreadPoolExecutor(max_workers=4) + + def call(): + return list(pool.map(lambda _: plan.evaluate_array(bindings), range(4)))[0] + else: + + def call(): + return expr.compute(_require_native=True, _getitem=True) + + first, first_ms = timed(call) + warm = [timed(call)[1] for _ in range(5)] + np.testing.assert_array_equal(first, reference) + if scenario == "threaded": + pool.shutdown() + return { + "scenario": scenario, + "compile_ms": compile_ms, + "first_ms": first_ms, + "warm_median_ms": statistics.median(warm), + "load_ms": load_ms if scenario == "persisted" else None, + "size": 8192, + "threads": 4 if scenario == "threaded" else 1, + "peak_rss_bytes": peak_rss_bytes(), + "native_report": getattr(expr, "_native_execution_report", None), + "extension_sha256": hashlib.sha256(Path(blosc2.blosc2_ext.__file__).read_bytes()).hexdigest(), + "python_revision": subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip(), + "note": "Four independent concurrent calls" + if scenario == "threaded" + else "Existing portable recipe block scheduler" + if scenario == "persisted" + else "Native logical scheduler", + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--worker", nargs=5) + parser.add_argument("--report", type=Path) + parser.add_argument("--scenario", choices=["mixed", "partial", "compressed", "persisted", "threaded"]) + parser.add_argument("--supplement-existing", action="store_true") + args = parser.parse_args() + if args.scenario: + print(json.dumps(supplement(args.scenario))) + return + if args.worker: + size, dtype, route, layout, reduction = args.worker + print(json.dumps(worker(int(size), dtype, route, layout, reduction == "sum"))) + return + if args.report is None: + parser.error("--report is required") + if args.supplement_existing: + report = json.loads(args.report.read_text()) + report["supplemental"] = [] + for scenario in ["mixed", "partial", "compressed", "persisted", "threaded"]: + p = subprocess.run( + [sys.executable, "-m", "tools.menudet_graph_bench", "--scenario", scenario], + capture_output=True, + text=True, + check=True, + ) + report["supplemental"].append(json.loads(p.stdout)) + args.report.write_text(json.dumps(report, indent=2) + "\n") + return + rows = [] + cases = [ + (n, d, layout, r) + for n in (8, 262144) + for d in ("float32", "float64", "int64") + for layout in ("C", "strided") + for r in ("none", "sum") + ] + for index, (size, dtype, layout, reduction) in enumerate(cases): + routes = ["native", "graph", "numpy", "numexpr", "blosc2"] + if index % 2: + routes.reverse() + for route in routes: + environment = {**os.environ, "BLOSC_NTHREADS": "1", "NUMEXPR_NUM_THREADS": "1"} + p = subprocess.run( + [ + sys.executable, + "-m", + "tools.menudet_graph_bench", + "--worker", + str(size), + dtype, + route, + layout, + reduction, + ], + env=environment, + capture_output=True, + text=True, + check=True, + ) + rows.append(json.loads(p.stdout)) + args.report.write_text( + json.dumps( + { + "platform": platform.platform(), + "rows": rows, + "limitations": [ + "Process peak RSS includes interpreter/imports/reference allocations.", + "One serial native thread; compressed input frontend not timed in this matrix.", + "Compilation measured for native plan; control-route parsing is included in first run.", + "No universal speed budget or speedup claim.", + ], + }, + indent=2, + ) + + "\n" + ) + + +if __name__ == "__main__": + main() diff --git a/tools/menudet_jit_bench.py b/tools/menudet_jit_bench.py new file mode 100644 index 000000000..59ede9c35 --- /dev/null +++ b/tools/menudet_jit_bench.py @@ -0,0 +1,171 @@ +"""Isolated actual-JIT comparisons; compilation excluded from warm execution.""" + +import argparse +import hashlib +import json +import os +import platform +import shutil +import statistics +import subprocess +import sys +import time +from pathlib import Path +from tempfile import TemporaryDirectory + +import numpy as np + +import blosc2 + +EXPRESSIONS = { + "affine": "x * 2 + y / 3 - 1", + "polynomial": "(x + y) * (x - y)", + "where": "where(x > 0, y / x, x * 2 + y)", +} + + +def timed(call): + start = time.perf_counter_ns() + result = call() + return result, (time.perf_counter_ns() - start) / 1e6 + + +def worker(route, workload, dtype, size, api): + x = np.linspace(-2, 2, size, dtype=dtype) + y = np.linspace(1, 2, size, dtype=dtype) + bindings = {"x": x, "y": y} + expression = EXPRESSIONS[workload] + compile_ms = None + has_jit = False + if route in {"tcc", "gcc", "interpreter"}: + os.environ["ME_DSL_JIT_COMPILER"] = "cc" if route == "gcc" else "tcc" + if route == "gcc": + os.environ["CC"] = os.environ.get( + "MENUDET_GCC", shutil.which("gcc-16") or shutil.which("gcc") or "cc" + ) + source = f"def k(x, y):\n return {expression}\n" + artifact = blosc2.DSLKernel.from_source(source).export( + {"x": dtype, "y": dtype}, dtype, version="1.0" + ) + kernel, compile_ms = timed( + lambda: blosc2.PortableKernel.from_json(artifact, jit=route != "interpreter") + ) + has_jit = kernel.has_jit + if has_jit != (route != "interpreter"): + raise RuntimeError(f"{route} backend eligibility/execution mismatch") + + def call(): + return kernel.evaluate(bindings) if api == "flat" else kernel.evaluate_array(bindings) + elif route == "numpy": + + def call(): + if workload == "affine": + return x * 2 + y / 3 - 1 + if workload == "polynomial": + return (x + y) * (x - y) + return np.where(x > 0, y / x, x * 2 + y) + else: + try: + import numexpr + except ImportError: + return { + "route": route, + "workload": workload, + "dtype": dtype, + "size": size, + "api": api, + "status": "unavailable", + "reason": "NumExpr is an optional external reference", + } + + numexpr.set_num_threads(1) + + def call(): + return numexpr.evaluate(expression, local_dict=bindings) + + first, first_ms = timed(call) + warm = [timed(call)[1] for _ in range(3 if route == "interpreter" else 9)] + reference = ( + x * 2 + y / 3 - 1 + if workload == "affine" + else (x + y) * (x - y) + if workload == "polynomial" + else np.where(x > 0, y / x, x * 2 + y) + ) + np.testing.assert_array_equal(first, reference) + return { + "route": route, + "workload": workload, + "dtype": dtype, + "size": size, + "api": api, + "compile_ms": compile_ms, + "first_ms": first_ms, + "warm_median_ms": statistics.median(warm), + "warm_samples_ms": warm, + "has_jit": has_jit, + "threads": 1, + "tile_items": 1024 if api == "array" else None, + "compiler": os.environ.get("CC") if route == "gcc" else route, + "extension_sha256": hashlib.sha256(Path(blosc2.blosc2_ext.__file__).read_bytes()).hexdigest(), + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--worker", nargs=5) + parser.add_argument("--report", type=Path) + args = parser.parse_args() + if args.worker: + route, workload, dtype, size, api = args.worker + with TemporaryDirectory(dir=os.environ["MENUDET_WORK_DIR"]) as cache: + os.environ["ME_DSL_JIT_CACHE_DIR"] = cache + print(json.dumps(worker(route, workload, dtype, int(size), api))) + return + if not args.report: + parser.error("--report is required") + rows = [] + for size in (8, 262144): + for dtype in ("float32", "float64"): + for workload in EXPRESSIONS: + for route in ("interpreter", "tcc", "gcc", "numpy", "numexpr"): + for api in ("flat", "array") if route in {"tcc", "gcc"} else ("flat",): + p = subprocess.run( + [ + sys.executable, + "-m", + "tools.menudet_jit_bench", + "--worker", + route, + workload, + dtype, + str(size), + api, + ], + capture_output=True, + text=True, + check=True, + ) + rows.append(json.loads(p.stdout)) + args.report.write_text( + json.dumps( + { + "platform": platform.platform(), + "numpy": np.__version__, + "rows": rows, + "limitations": [ + "C-contiguous finite workloads; selected-lane diagnostics qualified separately.", + "No explicit SIMD added; GCC may autovectorize strict loops.", + "Native comparison bridge retains interpreter comparison semantics.", + "Fresh-process artifact compilation includes metadata inference, not export.", + "Compilation/first/warm separate; no process-wide speedup claim.", + ], + }, + indent=2, + ) + + "\n" + ) + + +if __name__ == "__main__": + main() diff --git a/tools/menudet_jit_interleaved.py b/tools/menudet_jit_interleaved.py new file mode 100644 index 000000000..4648372bb --- /dev/null +++ b/tools/menudet_jit_interleaved.py @@ -0,0 +1,190 @@ +"""Compare warm JIT/array-engine timings with rotating order in fresh processes.""" + +import argparse +import hashlib +import json +import os +import platform +import shutil +import statistics +import subprocess +import sys +from pathlib import Path +from tempfile import TemporaryDirectory + +import numpy as np + +import blosc2 +from tools.menudet_jit_bench import EXPRESSIONS, timed + +try: + import numexpr +except ImportError: + numexpr = None + + +def worker(): # noqa: C901 -- independent compile, warm-up, validation and sampling phases + """Compilation and correctness checks are outside all execution samples.""" + if numexpr is not None: + numexpr.set_num_threads(1) + x = np.linspace(-2, 2, 262144, dtype="float64") + y = np.linspace(1, 2, 262144, dtype="float64") + bindings = {"x": x, "y": y} + compilers = { + "gcc": os.environ.get("MENUDET_GCC", shutil.which("gcc-16") or shutil.which("gcc")), + "clang": os.environ.get("MENUDET_CLANG", shutil.which("clang")), + } + if not all(compilers.values()): + raise RuntimeError("Both GCC and Clang must be available") + compiled = {} + compile_rows = [] + for workload, expression in EXPRESSIONS.items(): + artifact = blosc2.DSLKernel.from_source(f"def k(x, y):\n return {expression}\n").export( + {"x": "float64", "y": "float64"}, "float64", version="1.0" + ) + compiled[workload] = {} + for backend in ("interpreter", "tcc", "gcc", "clang"): + os.environ["ME_DSL_JIT_COMPILER"] = "cc" if backend in compilers else "tcc" + if backend in compilers: + os.environ["CC"] = compilers[backend] + kernel, ms = timed( + lambda a=artifact, b=backend: blosc2.PortableKernel.from_json(a, jit=b != "interpreter") + ) + if kernel.has_jit != (backend != "interpreter"): + raise RuntimeError(f"Unexpected JIT eligibility: {workload}/{backend}") + compiled[workload][backend] = kernel + compile_rows.append({"workload": workload, "backend": backend, "compile_ms": ms}) + + def numpy_call(workload): + if workload == "affine": + return x * 2 + y / 3 - 1 + if workload == "polynomial": + return (x + y) * (x - y) + return np.where(x > 0, y / x, x * 2 + y) + + calls = {} + for workload, expression in EXPRESSIONS.items(): + calls[workload] = { + backend: lambda k=kernel: k.evaluate(bindings) for backend, kernel in compiled[workload].items() + } + calls[workload]["numpy"] = lambda w=workload: numpy_call(w) + if numexpr is not None: + calls[workload]["numexpr"] = lambda e=expression: numexpr.evaluate(e, local_dict=bindings) + expected = numpy_call(workload) + # One untimed complete execution per backend warms code and engine caches. + for call in calls[workload].values(): + np.testing.assert_array_equal(call(), expected) + + rows = [] + workloads = list(EXPRESSIONS) + for round_number in range(30): + # Rotate workload order as well as backend order; all backends see the + # same buffers in the same process. The slow interpreter takes three + # samples, matching the original benchmark's sample budget. + for slot in range(len(workloads)): + workload = workloads[(slot + round_number) % len(workloads)] + backends = list(calls[workload]) + if round_number >= 3: + backends.remove("interpreter") + shift = round_number % len(backends) + for position, backend in enumerate(backends[shift:] + backends[:shift]): + result, ms = timed(calls[workload][backend]) + rows.append( + { + "workload": workload, + "backend": backend, + "round": round_number, + "position": position, + "ms": ms, + } + ) + del result + for workload in workloads: + expected = numpy_call(workload) + for call in calls[workload].values(): + np.testing.assert_array_equal(call(), expected) + return { + "samples": rows, + "compile_rows": compile_rows, + "compilers": compilers, + "extension_sha256": hashlib.sha256(Path(blosc2.blosc2_ext.__file__).read_bytes()).hexdigest(), + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--worker", action="store_true") + parser.add_argument("--report", type=Path) + parser.add_argument("--processes", type=int, default=5) + args = parser.parse_args() + if args.worker: + with TemporaryDirectory(dir=os.environ["MENUDET_WORK_DIR"]) as cache: + os.environ["ME_DSL_JIT_CACHE_DIR"] = cache + print(json.dumps(worker())) + return + if args.report is None or args.processes < 1: + parser.error("--report and a positive --processes are required") + processes = [] + for _ in range(args.processes): + result = subprocess.run( + [sys.executable, "-m", "tools.menudet_jit_interleaved", "--worker"], + capture_output=True, + text=True, + check=True, + ) + processes.append(json.loads(result.stdout)) + summary = [] + for workload in EXPRESSIONS: + for backend in ("interpreter", "tcc", "gcc", "clang", "numpy", "numexpr"): + if backend == "numexpr" and numexpr is None: + continue + medians = [ + statistics.median( + r["ms"] for r in p["samples"] if r["workload"] == workload and r["backend"] == backend + ) + for p in processes + ] + summary.append( + { + "workload": workload, + "backend": backend, + "median_of_process_medians_ms": statistics.median(medians), + "process_medians_ms": medians, + } + ) + report = { + "platform": platform.platform(), + "numpy": np.__version__, + "numexpr": numexpr.__version__ if numexpr is not None else None, + "size": 262144, + "dtype": "float64", + "api": "flat", + "numexpr_threads": 1 if numexpr is not None else None, + "technique": "Rotating workload/backend order; untimed warm-up; identical shared buffers", + "samples_per_process": {"interpreter": 3, "other_backends": 30}, + "compiler_versions": { + name: subprocess.check_output([compiler, "--version"], text=True) + for name, compiler in processes[0]["compilers"].items() + }, + "summary": summary, + "processes": processes, + "limitations": [ + "No core affinity or frequency tracing; not proof of the prior timing cause.", + "Finite C-contiguous workloads; compilation excluded from warm timings.", + "Interpreter has a smaller sample budget and participates in initial rounds only.", + ], + } + args.report.write_text(json.dumps(report, indent=2) + "\n") + for workload in EXPRESSIONS: + print( + workload, + { + r["backend"]: round(r["median_of_process_medians_ms"], 3) + for r in summary + if r["workload"] == workload + }, + ) + + +if __name__ == "__main__": + main() diff --git a/tools/menudet_lowering_bench.py b/tools/menudet_lowering_bench.py new file mode 100644 index 000000000..3e2d0d01c --- /dev/null +++ b/tools/menudet_lowering_bench.py @@ -0,0 +1,105 @@ +"""Repeat the native lowering-coverage benchmark across fresh processes. + +This preserves the native harness's fixed order / best-of-warm methodology; +it measures coverage and interpreter speedups, not stable compiler rankings. +""" + +import argparse +import hashlib +import json +import os +import platform +import re +import statistics +import subprocess +from pathlib import Path +from tempfile import TemporaryDirectory + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("executable", type=Path) + parser.add_argument("--report", type=Path, required=True) + parser.add_argument("--processes", type=int, default=5) + args = parser.parse_args() + if args.processes < 1: + parser.error("--processes must be positive") + pattern = re.compile(r"^(.+?)\s+([\d.]+) I\s+([\d.]+) (JIT|fb)\s+([\d.]+) (JIT|fb)\s+([\d.]+) (JIT|fb)$") + processes = [] + raw = [] + for _ in range(args.processes): + with TemporaryDirectory(dir=os.environ["MENUDET_WORK_DIR"]) as cache: + environment = dict(os.environ, ME_DSL_JIT_CACHE_DIR=cache) + result = subprocess.run( + [str(args.executable.resolve()), "65536", "7"], + env=environment, + capture_output=True, + text=True, + check=True, + ) + if "value checks: all match interpreter" not in result.stdout: + raise RuntimeError(result.stdout + result.stderr) + rows = [] + for line in result.stdout.splitlines(): + match = pattern.match(line) + if match: + values = match.groups() + rows.append( + { + "case": values[0], + "interpreter_ms": float(values[1]), + "tcc_ms": float(values[2]), + "tcc_route": values[3], + "gcc_ms": float(values[4]), + "gcc_route": values[5], + "clang_ms": float(values[6]), + "clang_route": values[7], + } + ) + if len(rows) != 8: + raise RuntimeError(f"Unexpected benchmark output:\n{result.stdout}") + processes.append(rows) + raw.append(result.stdout) + summary = [] + for index, row in enumerate(processes[0]): + entry = {"case": row["case"]} + for backend in ("interpreter", "tcc", "gcc", "clang"): + samples = [process[index][f"{backend}_ms"] for process in processes] + entry[f"{backend}_ms"] = statistics.median(samples) + entry[f"{backend}_range_ms"] = [min(samples), max(samples)] + if backend != "interpreter": + routes = {process[index][f"{backend}_route"] for process in processes} + if len(routes) != 1: + raise RuntimeError(f"Inconsistent compilation: {row['case']}/{backend}") + entry[f"{backend}_route"] = routes.pop() + summary.append(entry) + report = { + "platform": platform.platform(), + "nitems": 65536, + "repeats": 7, + "technique": "Median across fresh processes of native best-of-warm timings; fixed backend order", + "limitations": [ + "Compilation excluded; not an interleaved compiler-ranking experiment.", + "Native harness compares result bytes with the interpreter.", + ], + "executable_sha256": hashlib.sha256(args.executable.read_bytes()).hexdigest(), + "linked_native_sha256": { + path.name: hashlib.sha256(path.read_bytes()).hexdigest() + for path in args.executable.resolve().parent.parent.glob("*miniexpr*") + if path.suffix in (".dylib", ".so", ".dll") + }, + "compiler_versions": { + compiler: subprocess.check_output([compiler, "--version"], text=True) + for compiler in ("gcc-16", "clang") + }, + "summary": summary, + "processes": processes, + "raw_output": raw, + } + args.report.write_text(json.dumps(report, indent=2) + "\n") + for row in summary: + print(row) + + +if __name__ == "__main__": + main() diff --git a/tools/menudet_numpy_compat.py b/tools/menudet_numpy_compat.py new file mode 100644 index 000000000..0dfbd8c01 --- /dev/null +++ b/tools/menudet_numpy_compat.py @@ -0,0 +1,413 @@ +"""Pinned NumPy vector generator and installed Python integration runner. + +The corpus is owned by miniexpr; pass its path explicitly. No sibling checkout or +native shared library is discovered. This tool never evaluates source with eval. +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import platform +import subprocess +import sys +import time +from pathlib import Path + +import numpy as np + +REFERENCE = "2.5.3" +REVISION = "checkpoint-1" + + +def encode(array): + array = np.asarray(array) + return array.astype(array.dtype.newbyteorder(">"), copy=False).tobytes().hex() + + +def decode(buffer): + dtype = np.dtype(buffer["dtype"]) + return ( + np.frombuffer(bytes.fromhex(buffer["hex"]), dtype=dtype.newbyteorder(">")) + .astype(dtype) + .reshape(buffer["shape"]) + ) + + +def buffer(array, name=None): + array = np.asarray(array) + result = { + "dtype": array.dtype.name, + "shape": list(array.shape), + "encoding": "raw-be-hex", + "hex": encode(array), + } + if name is not None: + result.update(name=name, category="array", layout="C") + return result + + +def reference(operation, arrays, literal): + x = arrays[0] + y = arrays[1] if len(arrays) > 1 else literal + binary = { + "add": np.add, + "subtract": np.subtract, + "multiply": np.multiply, + "divide": np.true_divide, + "floor_divide": np.floor_divide, + "remainder": np.remainder, + "less": np.less, + "left_shift": np.left_shift, + } + if operation in binary: + return binary[operation](x, y) + if operation == "cancel": + return (x + literal) - x + if operation == "negative": + return np.negative(x) + if operation == "absolute": + return np.absolute(x) + if operation.startswith("cast_"): + return x.astype(operation[5:]) + if operation == "sin": + return np.sin(x) + raise ValueError(operation) + + +def generate(): + if np.__version__ != REFERENCE: + raise RuntimeError(f"Generation requires NumPy {REFERENCE}, not {np.__version__}") + cases = [] + + def add( + identifier, operation, expression, dtype, values, literal=None, other=None, output=None, scalar=None + ): + arrays = [np.array(values, dtype=dtype)] + if other is not None: + arrays.append(np.array(other[1], dtype=other[0])) + with np.errstate(all="ignore"): + expected = np.asarray( + reference( + operation, arrays, np.asarray(scalar[1], dtype=scalar[0])[()] if scalar else literal + ) + ) + names = ["x", "y"][: len(arrays)] + artifact = { + "schema_version": "1.0", + "language": {"name": "miniexpr", "version": "1.0"}, + "requires": ["numeric"], + "source": f"def k({', '.join(names)}):\n return {expression}\n", + "entry_point": "k", + "inputs": [{"name": n, "dtype": a.dtype.name} for n, a in zip(names, arrays, strict=True)], + "constants": [], + "output": {"dtype": output or expected.dtype.name, "contract": "elementwise"}, + "semantics": {"fp": "strict", "numeric": "numpy-2.5", "casting": "unsafe"}, + "context": {"ndim": 0}, + "metadata": {}, + } + if scalar: + artifact["source"] = artifact["source"].replace("def k(x):", "def k(x, y):") + value = np.asarray(scalar[1], dtype=scalar[0]) + artifact["constants"] = [ + { + "name": "y", + "category": "typed_scalar", + "dtype": scalar[0], + "encoding": "ieee754-hex" if value.dtype.kind == "f" else "decimal", + "value": encode(value) if value.dtype.kind == "f" else str(int(value)), + } + ] + cases.append( + { + "id": identifier, + "operation": operation, + "semantic_revision": "menudet-numpy-1.0", + "requires": ["numeric"], + "artifact": json.dumps(artifact, sort_keys=True), + "inputs": [buffer(a, n) for n, a in zip(names, arrays, strict=True)], + "literal": None + if literal is None + else {"category": "weak", "type": type(literal).__name__, "decimal": str(literal)}, + "expected": buffer(expected.astype(artifact["output"]["dtype"])), + "comparison": {"kind": "bitwise", "nan": "bits", "signed_zero": "exact"}, + } + ) + if scalar: + cases[-1]["scalar_operands"] = [{"name": "y", "category": "typed_scalar", **buffer(value)}] + for item in cases[-1]["inputs"]: + if item["shape"] == []: + item["category"] = "zero_dimensional_array" + + for dtype in ("int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64"): + info = np.iinfo(dtype) + add(f"{dtype}-add-boundary", "add", "x + 1", dtype, [info.max - 1, info.max], 1) + add( + "int64-exact-subtract", + "subtract", + "x - 9007199254740993", + "int64", + [9007199254740993, 9007199254740994], + 9007199254740993, + ) + add("int8-multiply-boundary", "multiply", "x * 2", "int8", [63, 64], 2) + add("int8-negate-min", "negative", "-x", "int8", [-128, -1, 0]) + add("int64-absolute-min", "absolute", "abs(x)", "int64", [-(2**63), -1]) + add("float32-weak-literal", "cancel", "(x + 1.0) - x", "float32", [16777216, 2], 1.0) + add("float32-typed-float64-capture", "add", "x + y", "float32", [16777216, 2], scalar=("float64", 1.0)) + add("int8-typed-int64-capture", "add", "x + y", "int8", [127], scalar=("int64", 1)) + add("float32-zero-dimensional", "add", "x + 1.0", "float32", 16777216, 1.0) + add("int8-float-literal", "add", "x + 1.0", "int8", [127, 1], 1.0) + add("int8-uint8-promote", "add", "x + y", "int8", [-1, 127], other=("uint8", [255, 1])) + add("int64-uint64-promote", "add", "x + y", "int64", [-1, 2**63 - 1], other=("uint64", [0, 2**64 - 1])) + add("int64-uint64-compare", "less", "x < y", "int64", [-1, 2**63 - 1], other=("uint64", [0, 2**64 - 1])) + add("int64-uint64-compare-rounding", "less", "x < y", "int64", [2**53], other=("uint64", [2**53 + 1])) + add("bool-add", "add", "x + y", "bool", [True, False], other=("bool", [True, True]), output="int64") + add("int64-true-divide", "divide", "x / 3", "int64", [-7, 7], 3) + add("int64-floor-divide", "floor_divide", "x // -3", "int64", [-7, 7], -3) + add("int64-remainder", "remainder", "x % -3", "int64", [-7, 7], -3) + add("int64-zero-divide", "floor_divide", "x // 0", "int64", [-7, 0, 7], 0) + add("int64-min-divide", "floor_divide", "x // -1", "int64", [-(2**63)], -1) + add("int8-large-shift", "left_shift", "x << 8", "int8", [1, -1], 8) + add("float64-cast-int", "cast_int64", "int(x)", "float64", [1.9, -1.9, -0.0]) + add("float64-cast-infinity", "cast_int64", "int(x)", "float64", [np.inf]) + add("int64-narrow-output", "cast_int8", "x", "int64", [127, 128, -129], output="int8") + add("float32-cast-float", "cast_float64", "float(x)", "float32", [1.25, -0.0], output="float64") + add("float32-sin", "sin", "sin(x)", "float32", [0.0, -0.0]) + for case in cases: + if case["id"] == "float64-cast-infinity": + case["platform_qualification"] = ( + "NumPy nonfinite-to-integer sentinel is host-specific; not a universal contract." + ) + return { + "schema_version": "menudet-numpy-vectors-1", + "generator_revision": REVISION, + "reference": { + "numpy": REFERENCE, + "intp_bits": np.dtype(np.intp).itemsize * 8, + "byteorder": sys.byteorder, + "platform": platform.platform(), + "machine": platform.machine(), + "floating_errors": "ignore", + "python": platform.python_version(), + }, + "cases": cases, + } + + +def integrate(corpus, repeats=1): + import blosc2 + + results = [] + for case in corpus["cases"]: + start = time.perf_counter_ns() + try: + kernel = blosc2.PortableKernel.from_json(case["artifact"], jit=True) + compile_ns = time.perf_counter_ns() - start + inputs = {item["name"]: decode(item) for item in case["inputs"]} + start = time.perf_counter_ns() + for _ in range(repeats): + actual = kernel.evaluate(inputs) + elapsed = time.perf_counter_ns() - start + result = { + "id": case["id"], + "status": 0, + "backend": "jit" if kernel.has_jit else "interpreter", + "output": buffer(actual), + "compile_ns": compile_ns, + "evaluation_ns": elapsed // repeats, + } + except blosc2.PortableArtifactError as error: + statuses = {"invalid_source": -3, "evaluation_error": -5} + result = { + "id": case["id"], + "status": statuses.get(error.status, error.native_status), + "category": error.status, + "native_status": error.native_status, + "message": str(error), + "backend": "interpreter", + } + results.append(result) + extension = Path(blosc2.blosc2_ext.__file__) + return { + "numpy": np.__version__, + "package": blosc2.__file__, + "extension": str(extension), + "extension_sha256": hashlib.sha256(extension.read_bytes()).hexdigest(), + "results": results, + } + + +def check_baseline(corpus, report): + for case, actual in zip(corpus["cases"], report["results"], strict=True): + baseline = case["baseline"] + if actual["id"] != case["id"] or actual["status"] != baseline["status"]: + raise AssertionError(f"Changed diagnostic baseline: {case['id']}: {actual}") + if actual["status"] == 0 and actual["output"]["hex"] != baseline["hex"]: + raise AssertionError(f"Changed value baseline: {case['id']}: {actual}") + if actual["status"] == 0: + signature = json.loads(case["artifact"])["output"]["dtype"] + if ( + actual["output"]["dtype"] != signature + or actual["output"]["shape"] != case["inputs"][0]["shape"] + ): + raise AssertionError(f"Changed dtype/shape baseline: {case['id']}") + if actual["backend"] not in {"interpreter", "jit"}: + raise AssertionError(f"Invalid backend: {case['id']}") + + +def reference_drift(corpus): + differences = [] + for case in corpus["cases"]: + arrays = [decode(item) for item in case["inputs"]] + literal = case["literal"] + value = ( + None if literal is None else {"int": int, "float": float}[literal["type"]](literal["decimal"]) + ) + if case.get("scalar_operands"): + value = decode(case["scalar_operands"][0])[()] + with np.errstate(all="ignore"): + actual = buffer( + reference(case["operation"], arrays, value).astype( + json.loads(case["artifact"])["output"]["dtype"] + ) + ) + if actual != case["expected"]: + differences.append({"id": case["id"], "actual": actual, "expected": case["expected"]}) + return {"version_changed": np.__version__ != corpus["reference"]["numpy"], "differences": differences} + + +def benchmark(): + try: + import numexpr + except ImportError: + numexpr = None + + import blosc2 + + rows = [] + for dtype in ("float32", "float64", "int64"): + artifact = blosc2.DSLKernel.from_source("def k(x):\n return x * 2 + 1\n").export( + {"x": dtype}, dtype + ) + start = time.perf_counter_ns() + kernel = blosc2.PortableKernel.from_json(artifact, jit=True) + compile_ns = time.perf_counter_ns() - start + for count in (16, 262144): + x = np.arange(count, dtype=dtype) + engines = { + "portable": lambda x=x, kernel=kernel: kernel.evaluate({"x": x}), + "numpy": lambda x=x: x * 2 + 1, + } + if numexpr is not None: + engines["numexpr"] = lambda x=x: numexpr.evaluate("x * 2 + 1", local_dict={"x": x}) + for name, engine in engines.items(): + start = time.perf_counter_ns() + actual = engine() + first_ns = time.perf_counter_ns() - start + np.testing.assert_array_equal(actual, x * 2 + 1) + samples = [] + for _ in range(7): + start = time.perf_counter_ns() + engine() + samples.append(time.perf_counter_ns() - start) + rows.append( + { + "dtype": dtype, + "nitems": count, + "engine": name, + "compile_ns": compile_ns if name == "portable" else None, + "first_ns": first_ns, + "median_ns": int(np.median(samples)), + "backend": ("jit" if kernel.has_jit else "interpreter") + if name == "portable" + else name, + } + ) + return { + "platform": platform.platform(), + "numpy": np.__version__, + "numexpr": numexpr.__version__ if numexpr is not None else None, + "extension_sha256": hashlib.sha256(Path(blosc2.blosc2_ext.__file__).read_bytes()).hexdigest(), + "numexpr_threads": numexpr.get_num_threads() if numexpr is not None else None, + "samples": 7, + "results": rows, + "limitations": "Single process, fixed order, allocated output; no RSS or direct-native large-array timing.", + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("action", choices=["generate", "run", "record", "benchmark"]) + parser.add_argument("corpus", type=Path) + parser.add_argument("--native-runner", type=Path) + parser.add_argument("--native-revision", help="Explicit source SHA used to build the standalone runner") + parser.add_argument( + "--installed-native-revision", help="Explicit dependency SHA used to build the installed extension" + ) + parser.add_argument("--report", type=Path) + parser.add_argument("--repeats", type=int, default=20) + args = parser.parse_args() + if args.repeats < 1: + parser.error("--repeats must be positive") + if args.action == "benchmark": + report = benchmark() + report["installed_native_revision"] = args.installed_native_revision + args.corpus.write_text(json.dumps(report, indent=2) + "\n") + return + if args.action == "generate": + args.corpus.write_text(json.dumps(generate(), indent=2) + "\n") + return + corpus = json.loads(args.corpus.read_text()) + if corpus["schema_version"] != "menudet-numpy-vectors-1": + raise ValueError("Unsupported vector schema") + report = integrate(corpus, args.repeats) + report["provenance"] = { + "python_revision": subprocess.check_output( + ["git", "rev-parse", "HEAD"], cwd=Path(__file__).resolve().parents[1], text=True + ).strip(), + "native_revision": args.native_revision, + "installed_native_revision": args.installed_native_revision, + "local_changes": [ + "tools/menudet_numpy_compat.py", + "tests/test_menudet_numpy_compat.py", + "checkpoint reports", + ], + } + if args.action == "run": + check_baseline(corpus, report) + report["reference_drift"] = reference_drift(corpus) + if args.native_runner: + proc = subprocess.run( + [str(args.native_runner.resolve()), str(args.corpus.resolve())], + capture_output=True, + text=True, + check=True, + ) + report["native"] = [json.loads(line) for line in proc.stdout.splitlines()] + if args.action == "record": + if not args.native_runner: + parser.error("record requires --native-runner") + for case, native, python in zip(corpus["cases"], report["native"], report["results"], strict=True): + assert case["id"] == native["id"] == python["id"] + assert native["status"] == python["status"], (native, python) + if native["status"] == 0: + assert native["hex"] == python["output"]["hex"], (native, python) + case["baseline"] = { + "status": native["status"], + "hex": native.get("hex", ""), + "backend": "interpreter", + } + case["classification"] = ( + "matching" if native["status"] == 0 and python["output"] == case["expected"] else "divergent" + ) + args.corpus.write_text(json.dumps(corpus, indent=2) + "\n") + if args.report: + args.report.write_text(json.dumps(report, indent=2) + "\n") + else: + print(json.dumps(report, indent=2)) + + +if __name__ == "__main__": + main()